• 进程,线程,并发相关入门

    进程与线程的简单理解

    进程是一个独立的执行单元，它拥有自己的内存空间、文件句柄和系统资源.进程是操作系统层面的,每个应用运行就是一个进程.进程之间通常是隔离的，它们不能直接访问对方的内存空间，必须通过进程间通信（IPC）机制来进行数据交换。

    线程是进程内的执行单元,归属于进程，它共享进程的内存空间和资源。一个进程可以包含多个线程。但至少需要一个(普通)线程存活(守护线程不算).

    并行与并发:

    并行概念:并行是指多个进程或者多个线程同时执行任务,只是看起来并行,事实上没有真正的并行(暂时不存在真正意义上的并行,以后不知道).只是人类的感官觉得是并行.(即多核CPU中央处理器也无法达到真正并行)其实都是走走停停

    并发:并发是指在相同的时间段内处理多个任务或操作的能力。这并不一定意味着这些任务实际上是同时执行的，而是它们在某个时间间隔内交替执行，以创建一种错觉，似乎它们在同时进行。可以是线程,也可以是进行，一般是指多个线程同时抢占同一个资源,导致错误结果.俗称并发安全问题

    创建线程的第一种方式继承Thread,重写run方法

    1. public class Thread1 {
    2.  
    3.     public static void main(String[] args) {
    4.         Thread t1=new MyThread1();
    5.         Thread t2=new MyThread2();
    6.         t1.start();
    7.         t2.start();
    8.     }
    9. }
    10. //第一种方式:继承线程
    11. class MyThread1 extends Thread{
    12.     @Override
    13.     public void run() {
    14.         for(int i=0;i<100;i++){
    15.             System.out.println("你是谁呀");
    16.         }
    17.     }
    18. }
    19. class MyThread2 extends Thread{
    20.     @Override
    21.     public void run() {
    22.         for(int i=0;i<100;i++){
    23.             System.out.println("查水表的");
    24.         }
    25.     }
    26. }

    局部内部类写法

    1. public class Thread1 {
    2.  
    3.     public static void main(String[] args) {
    4.         Thread t1=new Thread(){
    5.             @Override
    6.             public void run() {
    7.                 for(int i=0;i<100;i++){
    8.                     System.out.println("你是谁呀");
    9.                 }
    10.             }
    11.         };
    12.         Thread t2=new Thread(){
    13.             @Override
    14.             public void run() {
    15.                 for(int i=0;i<100;i++){
    16.                     System.out.println("你是谁呀");
    17.                 }
    18.             }
    19.         };
    20.         t1.start();
    21.         t2.start();
    22.     }
    23. }

    匿名内部类写法

    1. public class Thread1 {
    2.  
    3.     public static void main(String[] args) {
    4.         new Thread(){
    5.             @Override
    6.             public void run() {
    7.                 for(int i=0;i<100;i++){
    8.                     System.out.println("你是谁呀");
    9.                 }
    10.             }
    11.         }.start();
    12.         new Thread(){
    13.             @Override
    14.             public void run() {
    15.                 for(int i=0;i<100;i++){
    16.                     System.out.println("你是谁呀");
    17.                 }
    18.             }
    19.         }.start();
    20.  
    21.     }
    22. }

    继承Thread的优点是写起来方便(特别是匿名内部类方式),缺点是Java是单继承的.继承了Thread之后无法再继承其他类.

    第二点是线程和线程要干的活有着强耦合关系

    创建线程的第二种方式.实现Runable接口.定义线程要执行的任务,将任务交给线程去执行

    1. public class Thread2 {
    2.  
    3.     public static void main(String[] args) {
    4.         //创建任务
    5.         MyRunable1 my1=new MyRunable1();
    6.         MyRunable2 my2=new MyRunable2();
    7.         //创建线程 并让线程启动任务
    8.         Thread t1=new Thread(my1);
    9.         Thread t2=new Thread(my2);
    10.         t1.start();
    11.         t2.start();
    12.     }
    13. }
    14. class MyRunable1 implements Runnable{
    15.  
    16.     @Override
    17.     public void run() {
    18.         for(int i=0;i<100;i++){
    19.             System.out.println("你是谁呀");
    20.         }
    21.     }
    22. }
    23. class MyRunable2 implements Runnable{
    24.  
    25.     @Override
    26.     public void run() {
    27.         for(int i=0;i<100;i++){
    28.             System.out.println("查水表的");
    29.         }
    30.     }
    31. }

    内部类写法

    1. public class Thread2 {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         //创建线程 并让线程启动任务
    6.         Thread t1=new Thread(new Runnable(){
    7.  
    8.             @Override
    9.             public void run() {
    10.                 for(int i=0;i<100;i++){
    11.                     System.out.println("你是谁呀");
    12.                 }
    13.             }
    14.         });
    15.         Thread t2=new Thread(new Runnable() {
    16.             @Override
    17.             public void run() {
    18.                 for(int i=0;i<100;i++){
    19.                     System.out.println("查水表的");
    20.                 }
    21.             }
    22.         });
    23.         t1.start();
    24.         t2.start();
    25.     }
    26. }

    匿名内部类写法

    1. public class Thread2 {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         //创建线程 并让线程启动任务
    6.        new Thread(new Runnable(){
    7.  
    8.             @Override
    9.             public void run() {
    10.                 for(int i=0;i<100;i++){
    11.                     System.out.println("你是谁呀");
    12.                 }
    13.             }
    14.         }).start();
    15.        new Thread(new Runnable() {
    16.             @Override
    17.             public void run() {
    18.                 for(int i=0;i<100;i++){
    19.                     System.out.println("查水表的");
    20.                 }
    21.             }
    22.         }).start();
    23.  
    24.     }
    25. }

    CurrentThread方法介绍:获取当前运行的线程

    1. public class Thread3 {
    2.     public static void main(String[] args) {
    3.         /**
    4.          * 线程提供了一个静态方法
    5.          * static Thread currentThread()
    6.          * 该方法用来获取运行这个方法的线程
    7.          * main方法也是靠一个线程运行的.当JVM启动
    8.          * 后会自动创建一个线程来执行main方法.称之为主线程
    9.          */
    10.         Thread thread = Thread.currentThread();
    11.         System.out.println(thread);//Thread[main,5,main]
    12.  
    13.         dosome();
    14.  
    15.         Thread t1=new Thread(){
    16.             @Override
    17.             public void run() {
    18.                 Thread t = Thread.currentThread();
    19.                 System.out.println("运行dosome方法的线程:"+t);//Thread[Thread-0,5,main]
    20.             }
    21.         };
    22.  
    23.         Thread t2=new Thread(){
    24.             @Override
    25.             public void run() {
    26.                 Thread t = Thread.currentThread();
    27.                 System.out.println("运行dosome方法的线程:"+t);//Thread[Thread-1,5,main]
    28.             }
    29.         };
    30.         t1.start();
    31.         t2.start();
    32.     }
    33.  
    34.     public static void dosome(){
    35.         Thread thread = Thread.currentThread();
    36.         System.out.println("运行dosome方法的线程:"+thread);//谁调用就是谁
    37.     }
    38. }

    线程相关信息的获取

    1. //线程提供了获取自身信息的相关方法
    2. public class Thread4 {
    3.  
    4.     public static void main(String[] args) {
    5.         //获取线程名
    6.         Thread thread = Thread.currentThread();
    7.         String name = thread.getName();
    8.         System.out.println("name:"+name);
    9.  
    10.         //获取线程的唯一标识(id)   线程名可以重  但是id不能重
    11.         long id = thread.getId();
    12.         System.out.println("该线程的id是:"+id);
    13.  
    14.         Thread t1=new Thread(){
    15.             @Override
    16.             public void run() {
    17.                 Thread t = Thread.currentThread();
    18.                 System.out.println("运行dosome方法的线程:"+t);//Thread[Thread-0,5,main]
    19.                 System.out.println("该线程的id是:"+t.getId());
    20.             }
    21.         };
    22.  
    23.         Thread t2=new Thread(){
    24.             @Override
    25.             public void run() {
    26.                 Thread t = Thread.currentThread();
    27.                 System.out.println("运行dosome方法的线程:"+t);//Thread[Thread-0,5,main]
    28.                 System.out.println("该线程的id是:"+t.getId());
    29.             }
    30.         };
    31.         t1.start();
    32.         t2.start();
    33.         //获取线程的优先级  1到10之间  默认都是5
    34.         int priority = thread.getPriority();
    35.         System.out.println("主线程的优先级:"+priority);
    36.  
    37.         boolean alive = thread.isAlive();
    38.         System.out.println("线程是否还活者:"+alive);
    39.  
    40.         boolean interrupted = thread.isInterrupted();
    41.         //中断就是让线程停了 一旦线程被中断（使用 interrupt() 方法中断），它的生命周期结束，不能重新启动.等待垃圾回收器回收
    42.         System.out.println("线程是否被中断:"+interrupted);
    43.  
    44.         //守护线程或称之为后台线程
    45.         boolean daemon = thread.isDaemon();
    46.         System.out.println("线程是否为守护线程:"+daemon);
    47.     }
    48. }

    一个个讲上面提到的方法

    首先线程优先级 int priority = thread.getPriority();  1到10之间  默认都是5

    线程优先级作用:干涉线程调度器工作 只能理论上尽量让该线程多获得CPU时间片,但是实际情况,说不好
    理论上:线程优先级越高,获得CPU时间片的次数越多. 优先级用整数表示: 10最高    1最低    默认5

    大于10或者小于1都会报错

    理论来讲应该是优先级高的先输出完,然后是默认的,然后是优先级最低的,但是实际效果是不一定

    调整线程优先级的结果未必理想,但是这是唯一可以改变争取或降低CPU时间片的方式

    1. //线程优先级
    2. public class PriorityDemo {
    3.     public static void main(String[] args) {
    4.         //线程优先级作用:干涉线程调度器工作 只能理论上尽量让该线程多获得CPU时间片,但是实际情况,说不好
    5.         //理论上:线程优先级越高,获得CPU时间片的次数越多. 优先级用整数表示: 10最高    1最低    默认5
    6.  
    7.         Thread max=new Thread(){
    8.             @Override
    9.             public void run() {
    10.                 for(int i=0;i<10000;i++){
    11.                     System.out.println("max");
    12.                 }
    13.             }
    14.         };
    15.         Thread min=new Thread(){
    16.             @Override
    17.             public void run() {
    18.                 for(int i=0;i<10000;i++){
    19.                     System.out.println("min");
    20.                 }
    21.             }
    22.         };
    23.         Thread norm=new Thread(){
    24.             @Override
    25.             public void run() {
    26.                 for(int i=0;i<10000;i++){
    27.                     System.out.println("norm");
    28.                 }
    29.             }
    30.         };
    31.         //如果设置的优先级>最高(10) 或者<(1)都会报错   抛IllegalArgumentException
    32.         //max.setPriority(10);
    33.         max.setPriority(Thread.MAX_PRIORITY);//用常量   设置优先级
    34.  
    35.         min.setPriority(Thread.MIN_PRIORITY);
    36.  
    37.         norm.setPriority(Thread.NORM_PRIORITY);
    38.  
    39.         max.start();
    40.         min.start();
    41.         norm.start();
    42.     }
    43. }

    sleep阻塞

    线程提供了一个静态方法:static void sleep(long ms)

    使运行这个方法的线程阻塞指定毫秒.超时后该线程会自动回到Runnable状态,

    等待再次获得CPU时间片运行 这个和计时器差不多

    1. public class Thread5 {
    2.  
    3.     public static void main(String[] args) {
    4.         System.out.println("程序开始了");
    5.         try {
    6.             Thread.sleep(5000);
    7.         } catch (InterruptedException e) {
    8.             e.printStackTrace();
    9.         }
    10.         System.out.println("程序结束了");
    11.     }
    12. }

    小案例:控制太输入倒计,每个1秒,到0停止

    java中一般会引起线程阻塞的方法都要求捕获InterruptedException中断异常

    1. public class Thread6 {
    2.     public static void main(String[] args) {
    3.         System.out.println("输入数字:");
    4.         Scanner scanner=new Scanner(System.in);
    5.         String line = scanner.nextLine();
    6.  
    7.         Integer num=Integer.parseInt(line);
    8.         for(;num>0;num--){
    9.             System.out.println(num);
    10.             try {
    11.                 Thread.sleep(1000);
    12.             } catch (InterruptedException e) {
    13.                 e.printStackTrace();
    14.             }
    15.         }
    16.         System.out.println("结束");
    17.     }
    18. }

    sleep阻塞demo2

    sleep方法要求必须处理中断异常,原因在于当一个线程调用了sleep方法处于阻塞状态的过程中其他线程中若调用了它的interupt()方法中断时,它就会在sleep方法中抛出中断异常.这时并非是将这个线程直接中断,而是中断了它的阻塞状态.

      

    1. public class Thread7 {
    2.  
    3.     public static void main(String[] args) {
    4.         Thread lin=new Thread(){
    5.             @Override
    6.             public void run() {
    7.                 //while(!Thread.currentThread().isInterrupted()) {
    8.                     System.out.println("林:刚美完容,睡一觉");
    9.                     try {
    10.                         Thread.sleep(10000000);
    11.                     } catch (InterruptedException e) {
    12.                         System.out.println("林:干嘛呢?干嘛呢?");
    13.                     }
    14.                 //}
    15.                 System.out.println("林:醒了");
    16.             }
    17.         };
    18.  
    19.         Thread huang=new Thread(){
    20.             @Override
    21.             public void run() {
    22.                 System.out.println("黄:开始砸墙!");
    23.                 for(int i=0;i<5;i++){
    24.                     System.out.println("黄:80!");
    25.                     try {
    26.                         Thread.sleep(1000);
    27.                     } catch (InterruptedException e) {
    28.                         e.printStackTrace();
    29.                     }
    30.                 }
    31.                 System.out.println("咣当!");
    32.                 System.out.println("黄:搞定!");
    33.  
    34.  
    35.                 //中断lin线程
    36.                 lin.interrupt();//这里注意:JDK8之前这样写报错,报错原因JDK8之前要求局部内部类中要使用方法内的局部变量,那个变量前要加final
    37.  
    38.             }
    39.         };
    40.         lin.start();
    41.         huang.start();
    42.     }
    43. }

    守护线程

    守护线程又称后台线程,默认创建的线程都是普通线程或称为前台线程,线程提供了一个

    方法:void setDaemon(boolean on)

    只有调用该方法并传入为true时,该线程才会被设置为守护线程.

    守护线程在使用上于普通线程没有差别,但是在结束时机上有一个区别,即:线程结束时所有正在运行的守护线程都会被强制停止.

    进程的结束:当一个进程中所有的普通线程都结束时,进程即结束

    GC就是一个守护线程

    1. public class Thread8 {
    2.  
    3.     public static void main(String[] args) {
    4.         Thread rose=new Thread(){
    5.             @Override
    6.             public void run() {
    7.                 for(int i=0;i<5;i++){
    8.                     System.out.println("rose:let me go!");
    9.                     try {
    10.                         Thread.sleep(1000);
    11.                     } catch (InterruptedException e) {
    12.                         e.printStackTrace();
    13.                     }
    14.                 }
    15.                 System.out.println("rose:啊啊啊啊啊啊啊啊啊!!!!!");
    16.             }
    17.         };
    18.  
    19.         Thread jack=new Thread(){
    20.             @Override
    21.             public void run() {
    22.                 while(true){
    23.                     System.out.println("jack:you jump! I jump!");
    24.                     try {
    25.                         Thread.sleep(1000);
    26.                     } catch (InterruptedException e) {
    27.                         e.printStackTrace();
    28.                     }
    29.                 }
    30.             }
    31.         };
    32.         Thread disanzhe=new Thread(){
    33.             @Override
    34.             public void run() {
    35.                 for(int i=0;i<10;i++) {
    36.                     System.out.println("disanzhe:吃瓜!看热闹");
    37.                     try {
    38.                         Thread.sleep(1000);
    39.                     } catch (InterruptedException e) {
    40.                         e.printStackTrace();
    41.                     }
    42.                 }
    43.             }
    44.         };
    45.  
    46.         rose.start();
    47.         jack.setDaemon(true);//设置为守护线程,要在启动前设置  有几个线程启动就守护几个线程
    48.         jack.start();
    49.         disanzhe.start();
    50.         //原先的观点:main方法结束,程序退出.以后的观点就是:当所有前台线程结束,进程结束.才算结束
    51.         System.out.println("main方法结束");//这里是main先结束
    52.  
    53.  
    54.         //这样的话,守护线程永远不会结束,原因是main线程还一致活者
    55. //        while(true){
    56. //
    57. //        }
    58.     }
    59. }

    join:协调线程之间的同步运行

    线程提供了一个方法:

    void join()

    该方法可以协调线程之间的同步运行

    同步与异步:

    同步:运行有顺序

    异步运行:运行代码无顺序,多线程并发运行就是异步运行

    多线程是异步运行的,但是有时候我们也需要他们同步---->利用join

    1. public class Thread9 {
    2.     private static boolean isFinish=false;//这个放在方法内编译不通过
    3.     public static void main(String[] args) {
    4.  
    5.         int a=1;
    6.         Thread download=new Thread(){
    7.             @Override
    8.             public void run() {
    9.                 System.out.println("down:开始下载图片");
    10.  
    11.                 for(int i=1;i<=100;i++){
    12.                     System.out.println("down:"+i+"%");
    13.                     try {
    14.                         Thread.sleep(200);
    15.                     } catch (InterruptedException e) {
    16.                         e.printStackTrace();
    17.                     }
    18.                 }
    19.                 System.out.println("down:下载图片完毕");
    20.                 isFinish=true;
    21.  
    22.             }
    23.         };
    24.         Thread show=new Thread(){
    25.             @Override
    26.             public void run() {
    27.                 System.out.println("show:开始显示图片");
    28.                 //加载图片前应先等待下载线程将图片下载完毕
    29.                 try {
    30.                     /**
    31.                      * show线程里调用download.join()方法后
    32.                      * 就进入了阻塞状态,知道download线程的run方法执行完毕才会解除
    33.                      */
    34.                     //这样可以使用应该和线程上下文有关
    35.                     download.join();//在show的线程里写  download.join() 就是等待download线程完毕
    36.                 } catch (InterruptedException e) {
    37.                     e.printStackTrace();
    38.                 }
    39.                 if(!isFinish){
    40.                     throw new RuntimeException("加载图片失败");
    41.                 }
    42.                 System.out.println("show:显示图片完毕");
    43.             }
    44.         };
    45.  
    46.         download.start();
    47.         show.start();
    48.     }
    49. }

    wait    用锁对象.wait()

    wait()方法其实主要做三件事：

    ①把当前线程放进等待队列中

    ②释放锁

    ③被其他线程唤醒时，尝试重新获取锁

    wait() 无参数版本

    wait(long) 指定最大等待时间，单位毫秒

    wait(long,int) 精度更高，前面是毫秒，后面是纳秒

    notifyAll():唤醒加了相同锁的所有线程

    wait和sleep其实是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间。这两个方法设计的初心是不同的，一个是单纯为了让线程进行阻塞等待而休眠一段时间，而一个是为了解决线程的执行顺序的问题。最明显的区别就是wait需要搭配锁使用，而sleep不需要。wait 是 Object 的方法 sleep 是 Thread 的静态方法。他们唯一的相同点就是都可以让线程进入阻塞等待状态。
     

    但是自测sleep无法唤醒,只能interrupt中断(不是很清楚)

    notify:用锁对象.notify() 唤醒

    1. public class Thread7 {
    2.  
    3.     public static void main(String[] args) {
    4.         Object o=new Object();
    5.         Thread lin=new Thread(){
    6.             @Override
    7.             public void run() {
    8.                 //while(!Thread.currentThread().isInterrupted()) {
    9.                     System.out.println("林:刚美完容,睡一觉");
    10.                     synchronized (o) {
    11.                         try {
    12.                             //Thread.sleep(1000000);
    13.                             o.wait();
    14.                         } catch (InterruptedException e) {
    15.                             System.out.println("林:干嘛呢?干嘛呢?");
    16.                         }
    17.                     }
    18.                 //}
    19.                 System.out.println("林:醒了");
    20.             }
    21.         };
    22.  
    23.         Thread huang=new Thread(){
    24.             @Override
    25.             public void run() {
    26.                 System.out.println("黄:开始砸墙!");
    27.                 for(int i=0;i<5;i++){
    28.                     System.out.println("黄:80!");
    29.                     try {
    30.                         Thread.sleep(1000);
    31.                     } catch (InterruptedException e) {
    32.                         e.printStackTrace();
    33.                     }
    34.                 }
    35.                 System.out.println("咣当!");
    36.                 System.out.println("黄:搞定!");
    37.                 //唤醒该锁线程,可以在线程里,方法里
    38.                 synchronized (o){
    39.                     o.notify();
    40.                 }
    41.  
    42.                 //中断lin线程
    43.                 //lin.interrupt();//这里注意:JDK8之前这样写报错,报错原因JDK8之前要求局部内部类中要使用方法内的局部变量,那个变量前要加final
    44.  
    45.             }
    46.         };
    47.         lin.start();
    48.         huang.start();
    49.     }
    50. }
    1. public class Thread10 {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Object lock = new Object();
    4.  
    5.         Thread thread1 = new Thread(() -> {
    6.             synchronized (lock) {
    7.                 try {
    8.                     lock.wait();
    9.                     System.out.println("Thread1被唤醒了");
    10.                 } catch (InterruptedException e) {
    11.                     e.printStackTrace();
    12.                     System.out.println("出错了");
    13.                 }
    14.             }
    15.         });
    16.  
    17.         Thread thread2 = new Thread(() -> {
    18.             synchronized (lock) {
    19.                 try {
    20.                     lock.wait();
    21.                     System.out.println("Thread2被唤醒了");
    22.                 } catch (InterruptedException e) {
    23.                     e.printStackTrace();
    24.                     System.out.println("出错了");
    25.                 }
    26.             }
    27.         });
    28.  
    29.         thread1.start();
    30.         thread2.start();
    31.  
    32.         Thread.sleep(5000);
    33.         synchronized (lock){
    34.             //lock.notify();
    35.             lock.notifyAll();
    36.         }
    37.     }
    38. }

    并发安全问题

    并发会出现的情况

    多线程并发的安全问题

    产生：当多个线程并发操作同一资源时,由于线程切换时机的不确定性,会导致

    执行操作资源的代码顺序未按照设计顺序执行,出现操作混乱的情况.

    严重时可能导致系统瘫痪.

    解决:将并发操作同一资源改为同步操作,即:有先后顺序的操作

    1. public class SyncDemo1 {
    2.  
    3.     public static void main(String[] args) {
    4.         Table table=new Table();
    5.         Thread t1=new Thread(){
    6.             @Override
    7.             public void run() {
    8.                 while(true){
    9.                     int bean=table.getBean();
    10.                     Thread.yield();
    11.                     System.out.println(getName()+":"+bean);
    12.                 }
    13.             }
    14.         };
    15.  
    16.         Thread t2=new Thread(){
    17.             @Override
    18.             public void run() {
    19.                 while(true){
    20.                     int bean=table.getBean();
    21.                     Thread.yield();
    22.                     System.out.println(getName()+":"+bean);
    23.                 }
    24.             }
    25.         };
    26.  
    27.         t1.start();
    28.         t2.start();
    29.         
    30.     }
    31. }
    32. class Table{
    33.     //20个豆子
    34.     private int bean=20;
    35.  
    36.     public int getBean(){
    37.         if(bean==0){
    38.             throw new RuntimeException("没有豆子了");
    39.         }
    40.         //模拟线程执行到这里没有时间了 它是告诉线程调度器,愿意主动让出CPU时间片,不能确保线程一定会让出
    41.         Thread.yield();
    42.         return bean--;
    43.     }
    44. }

    解决办法:加同步锁

    在getBean方法上加锁 synchronized   对方法枷锁  就是给对象枷锁

    但是在方法上加上synchronized会降低效率

    那么用同步块缩小控制范围

    同步块:语法

    synchronized(同步监视器对象){

            需要同步运行的代码片段

    }

    同步块可以更精准的控制需要同步运行的代码片段.有效的缩小同步范围可以在保证并发安全

    的前提下提高代码并发运行的效率

    使用同步块控制多线程同步运行必须要求这些线程看到的同步监视器对象为[同一个]

    有效缩小同步范围可以在保证

    1. public class SyncDemo2 {
    2.  
    3.     public static void main(String[] args) {
    4.         Shop shop=new Shop();
    5.         Thread t1=new Thread(){
    6.             @Override
    7.             public void run() {
    8.                 shop.buy();
    9.             }
    10.         };
    11.         Thread t2=new Thread(){
    12.             @Override
    13.             public void run() {
    14.                 shop.buy();
    15.             }
    16.         };
    17.         t2.start();
    18.     }
    19. }
    20. class Shop{
    21.     public void buy(){
    22.         try {
    23.             Thread t=Thread.currentThread();
    24.             System.out.println(t.getName()+":正在挑衣服");
    25.             Thread.sleep(5000);
    26.  
    27.             synchronized (this) {
    28.                 System.out.println(t.getName() + ":正在试衣服");
    29.                 Thread.currentThread();
    30.             }
    31.  
    32.             System.out.println(t.getName()+":结账离开");
    33.         } catch (InterruptedException e) {
    34.             e.printStackTrace();
    35.         }
    36.     }
    37. }

    静态方法加synchronized一定具有同步效果,锁的是类对象 Class的实例

    当静态方法加了synchronized,已经和对象无关了,无论你创建了多少个对象,

    必定会有同步效果

    1. public class SyncDemo3 {
    2.     public static void main(String[] args) {
    3.  
    4.         Foo f1=new Foo();
    5.         Foo f2=new Foo();
    6.  
    7.         Thread t1=new Thread(){
    8.             @Override
    9.             public void run() {
    10.                 //Foo.dosome();
    11.                 f1.dosome();
    12.             }
    13.         };
    14.  
    15.         Thread t2=new Thread(){
    16.             @Override
    17.             public void run() {
    18.                 //Foo.dosome();
    19.                 f2.dosome();
    20.             }
    21.         };
    22.  
    23.         t1.start();
    24.         t2.start();
    25.     }
    26. }
    27. class Foo{
    28.     public synchronized static void dosome(){
    29.         Thread t=Thread.currentThread();
    30.         System.out.println(t.getName()+":正在运行dosome方法");
    31.         try {
    32.             Thread.sleep(5000);
    33.         } catch (InterruptedException e) {
    34.             e.printStackTrace();
    35.         }
    36.         System.out.println(t.getName()+":运行dosome方法完毕");
    37.     }
    38. }

    synchronized的另外一种作用:

    synchronized称为同步锁,还可以帮助维护一种关系,互斥关系

    有你没我,有我没你.比如有A方法和B方法,我们希望出现的情况是:

    调用A方法就不能调用B,调用B方法就不能调用A,就是不能同时干两个方法

    比如咽下去东西和喘气就是互斥的,不能同时干

    如何在程序里实现互斥关系,希望互斥的代码用synchronized锁上,然后互斥的代码使用的锁是同一个,他们之间就是互斥关系

    互斥锁：

    当多个代码片段被synchronized块修饰后,这些同步块的同步监听器对象又是同一个时,这些代码片段就是互斥的.多个线程不能同时在这些方法中运行.

    注意:不一定是两个方法,可以是两个代码块,只要锁的对象是同一个,就有互斥效果

    1. public class SyncDemo4 {
    2.  
    3.     public static void main(String[] args) {
    4.         Boo boo=new Boo();
    5.         Thread t1=new Thread(){
    6.             @Override
    7.             public void run() {
    8.                 boo.methodA();
    9.             }
    10.         };
    11.         Thread t2=new Thread(){
    12.             @Override
    13.             public void run() {
    14.                 boo.methodA();
    15.             }
    16.         };
    17.         t1.start();
    18.         t2.start();
    19.     }
    20. }
    21. class Boo{
    22.     public synchronized void methodA(){
    23.         Thread t=Thread.currentThread();
    24.         try {
    25.             System.out.println(t.getName()+":正在运行A方法");
    26.             Thread.sleep(5000);
    27.             System.out.println(t.getName()+":运行A方法结束");
    28.         } catch (InterruptedException e) {
    29.             e.printStackTrace();
    30.         }
    31.     }
    32.  
    33.     public synchronized void methodB(){
    34.         Thread t=Thread.currentThread();
    35.         try {
    36.             System.out.println(t.getName()+":正在运行B方法");
    37.             Thread.sleep(5000);
    38.             System.out.println(t.getName()+":运行B方法结束");
    39.         } catch (InterruptedException e) {
    40.             e.printStackTrace();
    41.         }
    42.     }
    43. }

    关于Thread的静态方法 static void yield()

    该方法用于使当前线程主动让出当次CPU时间片回到Runable状态,等待分配时间片

    上面这图就是线程运行状态

    线程.start()之后进入可运行状态（并不是立刻执行,而是交给线程调度器,进入可运行状态,线程调度器把CPU时间分配给谁,谁先执行,不一定说先start的就一定先执行）,当获得CPU时间之后开始运行,CPU时间片用完了,回到可运行状态,等待线程调度分配CPU时间片,任务完成(run方法执行完毕)等待被回收.线程调度器无序分配CPU时间片,只能说尽量分配获得CPU时间片的时间均匀,但不保证

    线程有三种阻塞状态,分别是IO阻塞     Sleep阻塞   Wait阻塞  阻塞的直观表现就是卡了

    IO阻塞常见的比如说Scanner      Sleep阻塞比如说Thread.sleep  

    执行某些特殊代码,让线程进入阻塞状态

  • 相关阅读:
    《重构代码设计》
    git: ‘lfs‘ is not a git command unclear
    文件上传漏洞之upload-labs
    风控策略精准运维的制胜点，一个重要却容易被轻视的内容
    C语言——写一个函数，每调用一次这个函数，就会将num的值增加1
    基于评论文本的自适应特征提取推荐研究
    SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.6 变更缓存供应商 Redis
    物联网技术应用属于什么专业分类
    线程和进程的区别
    SpringMVC如何获取复选框中的值呢？
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/132892804