Java Day 13

线程的状态
 被创建 运行 冻结 消亡
 
 被创建--start()--> 运行
 运行----run()----> 消亡
         stop()
 运行---sleep(time)---> 冻结
        wait()-->
        <--notify()
 
 cpu 执行资格 被cup处理、处于队列中
 cpu 执行权   正在被cpu处理

创建线程的第二种方法
 实现Runnable接口
 
 Thread t1 = new Thread(d)//d是实现Runnable接口类创建的对象
 1、定义类实现Runnable接口
 2、覆盖接口中的run方法，将线程任务封装
 3、通过Thread类创建线程对象，将对象作为线程构造函数的参数进行传递
 4、调用线程对象的start方法

细节
 单独进行封装

线程安全问题
 1、多线程操作共享数据
 2、操作共享数据的线程代码有多条

同步代码块
 将多条操作共享数据的线程代码封装起来，只允许一个线程访问
 synchronized(对象){ 代码 }

同步代码块 利弊
 利 解决了线程的安全问题
 弊 效率降低

同步的前提 同步中必须有多个线程使用同一个锁

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

静态同步函数的锁
 函数所属字节码文件对象
 this.getClass();
 类.class

 class Ticket implements Runnable{ //extends Thread
     private int num = 100;
     Object obj = new Object();
     boolean flag = true;

     public void run(){
         //Object obj = new Object();
         if(flag){
             while(true){
                 show();
                 if(num==0)
                     return;
             }
         }else{
             while(true){
                 synchronized(this){
                     if(num>0){
                         try{
                             Thread.sleep(10);
                         }catch(InterruptedException e){
                         }
                     System.out.println(Thread.currentThread().getName()+"...block..."+num--);
                     }
             }
                 if(num==0)
                     return;
             //}
             }
         }

     }

     public synchronized void show(){
         if(num>0){
             try{
                 Thread.sleep(10);
             }catch(InterruptedException e){    }
             System.out.println(Thread.currentThread().getName()+"...func..."+num--);
         }
     }
 }

 public class SaleTicketsDemo{
     public static void main(String[] args){
         /*Ticket t1 = new Ticket();
         Ticket t2 = new Ticket();
         Ticket t3 = new Ticket();
         Ticket t4 = new Ticket();

         t1.start();
         t2.start();
         t3.start();
         t4.start();*/
         Ticket t = new Ticket();
         Thread t1 = new Thread(t);
         Thread t2 = new Thread(t);

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

     }
 }

单例模式 的多线程问题

 class Single{
     private static Single s = null;
     private Single(){}
     public static Single getInstance(){
         if(s==null){
             synchronized(Single.class){
                 if(s==null){
                     s = new Single();
                 }
             }
         }
         return s;
     }
 }

死锁
 1、同步的嵌套

 class Test implements Runnable{
     private boolean flag;
     Test(boolean blag){
         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 DeadLockTest{
     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();
     }
 }