Java学习之多线程（线程安全问题及线程同步）

一、线程安全问题产生前提：
1、多线程操作共享数据
2、线程任务中有多条代码

 class Ticket implements Runnable
 {
     //2.共享数据
     private int num = 100;

     public void run()
     {
         while(true)
         {
             //3.多条代码
             if(num > 0)
             {
                 try{Thread.sleep(10);}catch(InterruptedException e){}
                 System.out.println(Thread.currentThread().getName()+"==="+num--);
             }
         }
     }
 }

 class TicketDemo
 {
     public static void main(String[] args)
     {
         Ticket t = new Ticket();
         //1.多线程操作同一个对象
         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();
     }
 }

运行结果：

出现线程安全问题了

二、解决线程安全问题

解决线程安全问题的两种方式：

①、同步代码块

格式：

 synchronized(对象)
 {
  　　//需要被同步的代码;
     ... ...
 }

解决上面线程安全问题的代码：

 class Ticket implements Runnable
 {
     //2.共享数据
     private int num = 100;
     //同步锁：对象
     private Object o=new Object();
     public void run()
     {
         while(true)
         {
             synchronized(o)
             {
                 //3.多条代码
                 if(num > 0)
                 {
                     try{Thread.sleep(10);}catch(InterruptedException e){}
                     System.out.println(Thread.currentThread().getName()+"==="+num--);
                 }
             }
         }
     }
 }

结果：

解决原理：多线程在使用同步代码块时，使用了同一个同步锁（Object的对象）

②、同步函数

格式：

 public synchronized 方法返回值类型 方法名(参数列表)
 {
  ... ...
 }

2.1、非静态同步函数

代码：

 class Ticket implements Runnable
 {
     //2.共享数据
     private int num = 100;
     //同步锁：对象
     //private Object o=new Object();
     public void run()
     {
         while(true)
         {
             /*
             synchronized(o)
             {
                 //3.多条代码
                 if(num > 0)
                 {
                     try{Thread.sleep(10);}catch(InterruptedException e){}
                     System.out.println(Thread.currentThread().getName()+"==="+num--);
                 }
             }
             */
             show();
         }
     }
     public synchronized void show()
     {
         //3.多条代码
         if(num > 0)
         {
             try{Thread.sleep(10);}catch(InterruptedException e){}
             System.out.println(Thread.currentThread().getName()+"==="+num--);
         }
     }
 }

结果：

2.2、静态同步函数

代码：

 class Ticket implements Runnable
 {
     //2.共享数据
     private static int num = 100;
     //同步锁：对象
     //private Object o=new Object();
     public void run()
     {
         while(true)
         {
             /*
             synchronized(o)
             {
                 //3.多条代码
                 if(num > 0)
                 {
                     try{Thread.sleep(10);}catch(InterruptedException e){}
                     System.out.println(Thread.currentThread().getName()+"==="+num--);
                 }
             }
             */
             show();
         }
     }
     public static synchronized void show()
     {
         //3.多条代码
         if(num > 0)
         {
             try{Thread.sleep(10);}catch(InterruptedException e){}
             System.out.println(Thread.currentThread().getName()+"==="+num--);
         }
     }
 }

结果：

总结：

同步的好处：解决线程的安全问题
同步的弊端：效率低，因为同步外的线程都会判断同步锁

同步的前提：必须有多个线程使用同一个同步锁（synchronized(同步锁：对象)）

同步代码块：可以指定任意对象作为同步锁

同步函数：非静态同步函数的同步锁为当前类对象（this），静态同步函数为当前类的字节码对象（类名.class或this.getClass()）