多线程同步基础

主线程执行完要等待其他线程执行完，才退出虚拟机

主线程执行完需要让其他线程也结束，可设置为守护线程，守护线程必须在线程启动前开启

实现方式和继承方式的区别：

实现方式好处避免了但继承的局限性(不能继承其他类，只能继承Thread类）

定义线程时，建议使用实现方式。

两种方式区别：

继承Thread：线程代码存放Thread子类的run方法中

实现Runnable：线程代码存放接口子类的run方法中

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

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

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

同步的两种表现形式：同步代码块和同步函数

同步代码块

Object obj = new Object(); synchronized(obj)             {                //todo             }

同步函数（使用的锁是this）

同步函数被静态修饰后使用的锁不再是this，因为静态方法中不可以有this,

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

public synchronized void add(int n)     {                     }

    public static synchronized void show()     {              }

同步代码块和同步函数要使用同一把锁需要让同步代码块的锁设为this或者类名.class

多线程单例最好写成饿汉式（函数里面只有一句话）

class Single {     private static final Single s = new Single();     private Single(){}     public static Single getInstance()     {         return 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;     } }

同步弊端死锁-同步嵌套，锁不一样

/* 死锁。 同步中嵌套同步。 */ class Ticket implements Runnable {     private  int tick = 1000;     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()//this     {         synchronized(obj)         {             if(tick>0)             {                 try{Thread.sleep(10);}catch(Exception e){}                 System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);             }         }     } } 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(Exception e){}         t.flag = false;         t2.start();     } }

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 {     static Object locka = new Object();     static Object lockb = new Object(); } class  DeadLockTest {     public static void main(String[] args)      {         Thread t1 = new Thread(new Test(true));         Thread t2 = new Thread(new Test(false));         t1.start();         t2.start();     } }