threadSynchronized

 

1   多线程安全问题

1.1 起因

在一个进程中，多个线程共享相同的资源（数据或者引用地址），出现的多个线程先后使用、更新或者删除数据造成的重复读，幻读或者脏读问题。

1.2 非安全线程—使用继承Thread类的方式

1.2.1   example

public class SellTicketThread extends Thread{

   int tickets=100;

   public void run(){

      while(tickets>0){

         System.out.println(getName()+"--"+tickets);

         tickets--;

      } 

   }

}

public static void main(String[] args){

      Thread t1=newSellTicketThread();

      Thread t2=newSellTicketThread();

      Thread t3=newSellTicketThread();

      Thread t4=newSellTicketThread();

      t1.setName("窗口1");

      t2.setName("窗口2");

      t3.setName("窗口3");

      t4.setName("窗口4");

      t1.start();

      t2.start();

      t3.start();

      t4.start();

   }

1.2.2解决方案

简单的多线程共享基本数据类型的数据时，使用线程子类内静态化属性的方法可以解决一部分重复读的问题，但是不能解决线程首次并发时的重复读问题。

public class SellTicketThread extends Thread{

   public static int tickets=100;

   public void run(){

      while(tickets>0){

         System.out.println(getName()+"--"+tickets);

         try {

            Thread.sleep(10);

         } catch (InterruptedExceptione) {

            e.printStackTrace();

         }

         tickets--;

      } 

   }

}

1.3 使用实现Runnable接口的方式

1.3.1   example   

简单的多线程共享基本数据类型的数据时，使用实现Runnable接口的方式时，由于线程只是实现了run方法，采用的是Runnable实现类的全局变量，而不是像实现Thread类的方式继承了Thread的属性，能够保持共享属性的完全隔离性（除首次开启线程时）。那么，采用实现接口的方式，在使用这个全局变量时，可能存在重复读，脏读，幻读等安全问题。

public class SellTicketTask implements Runnable{

   private static int ticket=100;

   public void run() {

      while(ticket>0){

         try {

            Thread.sleep(10);

         } catch (InterruptedExceptione1) {

            // TODO Auto-generatedcatch block

            e1.printStackTrace();

         }

         System.out.println(Thread.currentThread().getName()+"--"+ticket);

         try {

            Thread.sleep(10);

         } catch (InterruptedExceptione) {

            // TODO Auto-generatedcatch block

            e.printStackTrace();

         }

         ticket--;

      }

   }

}

1.3.2 解决方案

(1)      使用同步代码块

Synchronized(Object){

需要同步的代码

}

public class SellTicketTask implements Runnable{

   private int ticket=100;

   Object o=new Object();

   public void run() {

      while(ticket>0){

         synchronized(o){

            if(ticket>0){

               System.out.println(Thread.currentThread().getName()+"--"+ticket);

               try {

                  Thread.sleep(10);

               } catch (InterruptedExceptione) {

                  e.printStackTrace();

               }

               ticket--;

            }

         }

      }

   }

}

对于synchronized的锁对象的测试

public class SellTicketTask implements Runnable{

   private int ticket=100;

   Object o=new Object();

   Object o2=new Object();

   int a=1;

   public void run() {

      while(ticket>0){

         if(a==1){

            synchronized(o){

               if(ticket>0){

                  System.out.println(Thread.currentThread().getName()+"-1-"+ticket);

                  try {

                     Thread.sleep(10);

                  } catch (InterruptedExceptione) {

                     e.printStackTrace();

                  }

                  ticket--;

                  a=2;

               }

            }

         }

         if(a==2){

            synchronized(o){

               if(ticket>0){

                  System.out.println(Thread.currentThread().getName()+"-2-"+ticket);

                  try {

                     Thread.sleep(10);

                  } catch (InterruptedExceptione) {

                     e.printStackTrace();

                  }

                  ticket--;

                  a=3;

               }

            }

         }

         if(a==3){

            synchronized(o){

               if(ticket>0){

                  System.out.println(Thread.currentThread().getName()+"-3-"+ticket);

                  try {

                     Thread.sleep(10);

                  } catch (InterruptedExceptione) {

                     e.printStackTrace();

                  }

                  ticket--;

                  a=1;

               }

            }

         }



      }

   }

}

(2) 使用synchronized修饰非静态方法

如果一个方法内代码全部被synchronized代码块包裹，那么这个方法就可以定义为一个同步方法。格式将sychronized加到这个方法的修饰中。由于同步方法的锁就是当前的对象。所有，如果synchronized代码块和同步方法混合使用，需要将synchronized的对象锁设置为当前对象，也就是this。

public class SellTicketTask implements Runnable{

   private int ticket=100;

   Object o=new Object();

   Object o2=new Object();

   int a=1;

   public synchronized void synmethod(inta){

      if(ticket>0){

         System.out.println(Thread.currentThread().getName()+"-"+a+"-"+ticket);

         try {

            Thread.sleep(10);

         } catch(InterruptedExceptione) {

            e.printStackTrace();

         }

         ticket--;

         if(a==2){

            this.a=3;

         }

         if(a==3){

            this.a=1;

         }

      }

   }

   public void run() {

      while(ticket>0){

         if(a==1){

            synchronized(this){

               if(ticket>0){

                  System.out.println(Thread.currentThread().getName()+"-1-"+ticket);

                  try {

                     Thread.sleep(10);

                  } catch (InterruptedExceptione) {

                     e.printStackTrace();

                  }

                  ticket--;

                  a=2;

               }

            }

         }

         if(a==2){

            synmethod(2);

         }

         if(a==3){

            synmethod(3);

         }



      }

   }

}

(3) 使用synchronized修饰的静态方法

同步静态方法的格式同同步非静态方法，但是注意引用全局变量的修饰符和类属性使用类调用的问题。另外，静态方法的对象锁不是类的实例对象，因为静态方法的加载先于实例对象。那么，一般，类加载到内存中，最开始是将class文件字节码内容加载到内存，并将这些静态数据转换成方法区中的运行时数据结构，然后在堆中生成一个表示这个类的Class对象。一般，有三种方法得到这个加载类的Class对象。1，Object类的getClass方法；2，类名.class；3，Class类的forName方法。

public class SellTicketTask implements Runnable{

   private static int ticket=100;

   Object o=new Object();

   Object o2=new Object();

   static int a=1;

   public static synchronized void stasynmethod(inta){

      if(ticket>0){

         System.out.println(Thread.currentThread().getName()+"-"+a+"-"+ticket);

         try {

            Thread.sleep(10);

         } catch(InterruptedExceptione) {

            e.printStackTrace();

         }

         ticket--;

         if(a==2){

            SellTicketTask.a=3;

         }

         if(a==3){

            SellTicketTask.a=1;

         }

      }

   }

   public void run() {

      while(ticket>0){

         if(a==1){

            //synchronized(SellTicketTask.class){

            try {

               synchronized(Class.forName("com.edu.thread.SellTicketTask")){

               //synchronized(newSellTicketTask().getClass()){

                //使用3种方法得到运行类的class对象

                  if(ticket>0){

                     System.out.println(Thread.currentThread().getName()+"-1-"+ticket);

                     try {

                        Thread.sleep(10);

                     } catch(InterruptedExceptione) {

                        e.printStackTrace();

                     }

                     ticket--;

                     a=2;

                  }

               }

            } catch (ClassNotFoundExceptione) {

               e.printStackTrace();

            }

         }

         if(a==2){

            stasynmethod(2);

         }

         if(a==3){

            stasynmethod(3);

         }

      }

   }

}

2   利用锁解决懒汉式单例的多线程安全问题

2.1 单例模式原型

public class SingleHungry {

   private SingleHungrysingleH=new SingleHungry();

   private SingleHungry(){}

   public static SingleHungrygetSingleH(){

      return singleH;

   }

}

public class SingleLazy {

   private static SingleLazy singleL;

   private SingleLazy(){}

   public static SingleLazy getSingleL(){

     

      if(singleL==null){

         singleL=new SingleLazy();

      }

      returnsingleL;

   }

}

2.2 人为制造懒汉式的线程安全问题

public class SingleLazy {

   private static SingleLazy singleL;

   private SingleLazy(){}

   public static SingleLazy getSingleL(){

      if(singleL==null){

         try {

            Thread.sleep(100);

         } catch(InterruptedExceptione) {

            e.printStackTrace();

         }

         singleL=new SingleLazy();

      }

      return singleL;

   }

}

public class TestSingle implements Runnable{

   public void run() {

   System.out.println(Thread.currentThread().getName()+"--"+SingleLazy.getSingleL());

   }

}

public static void main(String[] args) throws InterruptedException{

      TestSinglets=new TestSingle();

      Threadt1=new Thread(ts,"lizi1");

      Threadt2=new Thread(ts,"lizi2");

      Threadt3=new Thread(ts,"lizi3");

      Threadt4=new Thread(ts,"lizi4");

      Threadt5=new Thread(ts,"lizi5");

      Threadt6=new Thread(ts,"lizi6");

      Threadt7=new Thread(ts,"lizi7");

      Threadt8=new Thread(ts,"lizi8");

      t1.start();

      t2.start();

      t3.start();

      t4.start();

      t5.start();

      t6.start();

      t7.start();

      t8.start();

   }

2.3  利用同步锁解决线程安全问题

public class SingleLazy {

   private static SingleLazy singleL;

   private SingleLazy(){}

   public static SingleLazy getSingleL(){

       //优先判断null,提高效率。

      if(singleL==null){

         synchronized(SingleLazy.class){

            if(singleL==null){

               try {

                  Thread.sleep(100);

               } catch(InterruptedExceptione) {

                  e.printStackTrace();

               }

               singleL=new SingleLazy();

            }

         }

      }

      return singleL;

   }

}

测试方法同上。

3   deadlock

3.1 什么是死锁

两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象。若无其他作用，它们都将无法推进下去。

产生死锁的四个条件：1，互斥条件；2，请求与保持条件；3，不剥夺条件；4，循环等待条件。

3.2 example

public class DeadLock implements Runnable{

   private Objecto1=new Object();

   private Objecto2=new Object();

   public void run() {

      while(true){

         synchronized(o1){

            System.out.println(Thread.currentThread().getName()+"--"+"拿刀");

            synchronized(o2){

               System.out.println(Thread.currentThread().getName()+"--"+"拿叉");

            }

         }

         synchronized(o2){

            System.out.println(Thread.currentThread().getName()+"--"+"拿叉");

            synchronized(o1){

               System.out.println(Thread.currentThread().getName()+"--"+"拿刀");

            }

         }

      }

   }

}