多线程2（安全问题、同步代码块、同步函数、死锁）

最新推荐文章于 2021-03-16 21:05:47 发布

海角秋风

最新推荐文章于 2021-03-16 21:05:47 发布

阅读量619

点赞数

分类专栏： Java笔记文章标签： java

本文链接：https://blog.csdn.net/haijiaoqiufeng/article/details/49272503

版权

Java笔记专栏收录该内容

24 篇文章 0 订阅

订阅专栏

线程安全问题

线程安全问题产生的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

需求：模拟4个线程同时卖100张票。
代码

 class Ticket implements Runnable{
        private int num = 100;
        public void run(){
              while(true ){
                    if(num > 0){
                          try{
                               Thread. sleep(10);
                         } catch(InterruptedException e){
                               e.printStackTrace();
                         }
                         System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
                   }
             }
       }
 }
 class TicketDemo{
        public static void main(String[] args){
             Ticket t = new Ticket();
             Thread t1 = new Thread(t);
             Thread t2 = new Thread(t);
             Thread t3 = new Thread(t);
             Thread t4 = new Thread(t);
             t1.start();
             t2.start();
             t3.start();
             t4.start();
       }
 }

运行结果
这里写图片描述
……

原因分析：
出现上图安全问题的原因在于Thread-0通过了if判断后，在执行到“num–”语句之前，num此时仍等于1。
CPU切换到Thread-1、Thread-2、Thread-3之后，这些线程依然可以通过if判断，从而执行“num–”的操作，因而出现了0、-1、-2的情况。
这里写图片描述

解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

火车上的卫生间—经典。

同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。

修改后代码

 class Ticket implements Runnable{
       private int num = 100;
       Object obj = new Object();
       public void run(){
              while(true ){
                    synchronized(obj ){
                          if(num > 0){
                               System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
                         }
                    } 
              }
       }
 }
 class TicketDemo{
        public static void main(String[] args){
             Ticket t = new Ticket();
             Thread t1 = new Thread(t);
             Thread t2 = new Thread(t);
             Thread t3 = new Thread(t);
             Thread t4 = new Thread(t);

             t1.start();
             t2.start();
             t3.start();
             t4.start();
       }
 }

运行结果：
这里写图片描述
……

原因分析：
上图显示安全问题已被解决，原因在于Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。因此，当num=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“num–”操作（此后num的值为0），并且跳出同步代码块后，才能抢到锁。其他线程即使抢到锁，然而，此时num值已为0，也就无法通过if语句判断，从而无法再执行“num–”的操作了，也就不会出现0、-1、-2等情况了。

这里写图片描述

如何找问题：
1，明确哪些代码是多线程运行代码。
2，明确共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。

利用同步代码块解决安全问题案例：
需求：储户，两个，每个都到银行存钱，每次存100，共存三次。

代码：

 class Bank{
        private int sum ;
        public void add(int num){
              synchronized(this ){
                    sum = sum + num;
                   System.out.println("sum = " + sum);
              }
        }
 }

运行结果：
这里写图片描述

原因分析：
由如下代码中可以看到，同步代码块中的语句，存在可能有多个线程同时操作共享数据（sum）的情况，通过同步代码块即可解决存在的安全问题。

这里写图片描述

如果不设置同步代码块，出现的结果如下：
这里写图片描述

安全问题的另一种解决方案：同步函数
格式：在函数上加上synchronized修饰符即可。

同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。

示例：

 class Bank{
        private int sum ;
        public synchronized void add(int num){ //同步函数
              sum = sum + num;
              System.out.println("sum = " + sum);
        }
 }

运行结果：
这里写图片描述

同步函数和同步代码块的区别：
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。

建议使用同步代码块。
由于同步函数的锁是固定的this，同步代码块的锁是任意的对象，那么如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

示例：

 class Ticket implements Runnable{
        private int num = 100;
        boolean flag = true;
        public void run(){
              if(flag ){
                    while(true ){
                          synchronized(this ){
                                if(num > 0){
                                      try{
                                           Thread. sleep(10);
                                      } catch(InterruptedException e){
                                           e.printStackTrace();
                                      }
                                      System. out.println(Thread.currentThread().getName() + "...obj..." + num--);
                               }
                         }
                   }
             } else
                    while(true )
                         show();
       }
        public synchronized void show(){
              if(num > 0){
                    try{
                         Thread. sleep(10);
                    } catch(InterruptedException e){
                         e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "...function..." + num--);
             }
       }
 }
 class SynFunctionLockDemo{
        public static void main(String[] args){
             Ticket t = new Ticket();
             Thread t1 = new Thread(t);
             Thread t2 = new Thread(t);

             t1.start();
              try{/*下面这条语句一定要执行。因为可能线程t1尚未真正启动，flag已经设置为false，那么当t1执行的时候，就会按照flag为false的情况执行，线程t2也按照flag为false的情况执行，实验就达不到目的了。*/
                   Thread. sleep(10);
             } catch(InterruptedException e){
                   e.printStackTrace();
             }
             t. flag = false ;
             t2.start();
       }
 }

运行结果：
这里写图片描述
……

如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证，发现不在是this。因为静态方法中也不可以定义this。
静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

示例：

 class Ticket implements Runnable{
        private static int num = 100;
       Object obj = new Object();
        boolean flag = true;
        public void run(){
              if(flag ){
                    while(true ){
                          synchronized(Ticket.class){//this.getClass()
                                if(num > 0){
                                      try{
                                           Thread. sleep(10);
                                      } catch(InterruptedException e){
                                           e.printStackTrace();
                                      }
                                      System.out.println(Thread.currentThread().getName() + "...obj..." + num--);
                               }
                         }
                   }
             } else
                    while(true )
                          show();
       }
       public static synchronized void show(){
              if(num > 0){
                    try{
                         Thread. sleep(10);
                   } catch(InterruptedException e){
                         e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "...function..." + num--);
             }
       }
 }
 class SynFunctionLockDemo{
        public static void main(String[] args){
             Ticket t = new Ticket();
             Thread t1 = new Thread(t);
             Thread t2 = new Thread(t);

             t1.start();
              try{
                   Thread. sleep(10);
             } catch(InterruptedException e){
                   e.printStackTrace();
             }
             t. flag = false ;
             t2.start();
       }
}

运行结果：
这里写图片描述
……

多线程下的单例模式
饿汉式

class Single
{
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }
}

P.S.
饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况。

懒汉式：

class Single
{
    private static Single s = null;
    private Single(){}


    public static  Single getInstance()
    {
        if(s==null)
        {
            synchronized(Single.class)
            {
                if(s==null)
                    //--->A;
                    s = new Single();
            }
        }
        return s;
    }
}

P.S.
懒汉式存在安全问题，可以使用同步函数解决。
但若直接使用同步函数，则效率较低，因为每次都需要判断。
这里写图片描述

但若采取如下方式，即可提升效率。
这里写图片描述

原因在于任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则再判断是否能够获取锁。
1. 如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。
2. 如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。

死锁

死锁常见情景：同步的嵌套。

示例1：

 class Ticket implements Runnable{
        private static int num = 100;
        Object obj = new Object();
        boolean flag = true;
        public void run(){
              if(flag ){
                    while(true ){
                          synchronized(obj ){
                               show();
                         }
                   }
             } else
                    while(true )
                         show();
       }
        public synchronized void show(){
              synchronized(obj ){
                    if(num > 0){
                          try{
                               Thread. sleep(10);
                         } 
                         catch(InterruptedException e) 
                         {
                               e.printStackTrace();
                         }
                         System.out.println(Thread.currentThread().getName() + "...function..." + num--);
                   }
             }
       }
 }
 class DeadLockDemo{
        public static void main(String[] args){
             Ticket t = new Ticket();
             Thread t1 = new Thread(t);
             Thread t2 = new Thread(t);

             t1.start();
              try{
                   Thread. sleep(10);
             } catch(InterruptedException e){
                   e.printStackTrace();
             }
             t. flag = false ;
             t2.start();
       }
}

运行结果：
这里写图片描述

原因分析：
由上图可以看到程序已经被锁死，无法向下执行。
由下图代码可以看到，run方法中的同步代码块需要获取obj对象锁，才能执行代码块中的show方法。
而执行show方法则必须获取this对象锁，然后才能执行其中的同步代码块。
当线程t1获取到obj对象锁执行同步代码块，线程t2获取到this对象锁执行show方法。同步代码块中的show方法因无法获取到this对象锁无法执行，show方法中的同步代码块因无法获取到obj对象锁无法执行，就会产生死锁。
这里写图片描述

示例2：

 class Test implements Runnable{
        private boolean flag ;
       Test( boolean flag){
              this.flag = flag;
       }
        public void run(){
              if(flag ){
                    while(true )
                          synchronized(MyLock.locka){
                               System.out.println(Thread.currentThread().getName() + "...if locka...");
                                synchronized(MyLock.lockb){
                                     System.out.println(Thread.currentThread().getName() + "...if lockb...");
                               }
                         }
             } else{
                    while(true )
                          synchronized(MyLock.lockb){
                               System.out.println(Thread.currentThread().getName() + "...else lockb...");
                                synchronized(MyLock.locka){
                                     System.out.println(Thread.currentThread().getName() + "...else locka...");
                         }
                   }
             }
       }
 }
 class MyLock{
        public static final Object locka = new Object();
        public static final Object lockb = new Object();
 }
 class DeadLockDemo{
        public static void main(String[] args){
             Test a = new Test(true );
             Test b = new Test(false );
             Thread t1 = new Thread(a);
             Thread t2 = new Thread(b);
             t1.start();
             t2.start();
       }
 }