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();
    }
}