线程同步、死锁

1.线程同步(即上锁，同步锁)实现的方式

1）同步代码块

synchronized(obj){  //obj称为同步监视器，obj要监视的对象

}

同步监视器只能是对象，推荐使用共享资源的对象,可以当前对象 this,也可以是其它的对象

public class Ticket1 implements Runnable{
    private int ticket=5;
    @Override
    public void run() {
        for(int i=0;i<100;i++){  //每个窗口排了100个人
            synchronized (this) {  //同步代码块
                if(ticket>0){//有票
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+(ticket--)+"张票");
                }
            }
        }
    }
}

public class TestTicket1 {
    public static void main(String[] args) {
        Ticket1 ticket=new Ticket1();
        //创建Thread类
        Thread t1=new Thread(ticket, "A窗口");
        Thread t2=new Thread(ticket,"B窗口");
        Thread t3=new Thread(ticket,"C窗口");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

2）同步方法

同步方法的同步监视器为当前对象this

public synchronized void 方法名(参数列表){

}

public class Ticket2 implements Runnable{
    private int ticket=5;
    @Override
    public void run() {
        for(int i=0;i<100;i++){  //每个窗口排了100个人
             //调用同步方法
            this.saleTicket();
        }
    }
    private synchronized void saleTicket(){  //无需指定同步监视器，同步监视器只能是当前对象this
        if(ticket>0){//有票
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在卖第"+(ticket--)+"张票");
        }
    }
}

public class TestTicket2 {
    public static void main(String[] args) {
        Ticket2 ticket=new Ticket2();
        //创建Thread类
        Thread t1=new Thread(ticket, "A窗口");
        Thread t2=new Thread(ticket,"B窗口");
        Thread t3=new Thread(ticket,"C窗口");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

2.死锁及解决

产生原因：多线程操作时，互相等待对方的资源

public class DeadLock extends Thread {
    private Object money;//钱
    private Object water;//水
    public boolean flag;//标识持有对象锁
    
    public DeadLock(Object money, Object water) {
        super();
        this.money = money;
        this.water = water;
    }

    @Override
    public void run() {
        if(flag){//true时，持有“钱”的锁
            synchronized (money) {
                System.out.println("有钱,等水");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (water) {
                    System.out.println("有水，等钱");
                }
            }
        }else{
            synchronized (water) {
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (money) {
                    System.out.println("有钱，等水");
                }
            }
            
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建共享资源的对象
        Object money=new Object();
        Object water=new Object();
        //创建线程类的对象
        DeadLock d1=new DeadLock(money, water);
        DeadLock d2=new DeadLock(money, water);
        d1.flag=true;
        d2.flag=false;
        //启动线程
        d1.start();
        d2.start();
    }
}

无法完成一个循环

如何解决死锁：不要让两个对象同时持有对象锁，采用互斥方式来解决

 把 synchronized嵌套改为同级并列

public class DeadLock2 extends Thread {
    private Object money;//钱
    private Object water;//水
    public boolean flag;//标识持有对象锁
    
    public DeadLock2(Object money, Object water) {
        super();
        this.money = money;
        this.water = water;
    }

    @Override
    public void run() {
        if(flag){//true时，持有“钱”的锁
            synchronized (money) {
                System.out.println("有钱,等水");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            synchronized (water) {
                System.out.println("有水，等钱");
            }
        }else{
            synchronized (water) {
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            synchronized (money) {
                System.out.println("有钱，等水");
            }
            
        }
    }

public class Test2 {
    public static void main(String[] args) {
        //创建共享资源的对象
        Object money=new Object();
        Object water=new Object();
        //创建线程类的对象
        DeadLock2 d1=new DeadLock2(money, water);
        DeadLock2 d2=new DeadLock2(money, water);
        d1.flag=true;
        d2.flag=false;
        //启动线程
        d1.start();
        d2.start();
    }
}

死锁的避免

银行家算法：该算法需要检查申请者对资源的最大需求量，如果系统现存的各类资源可以满足申请者的请求，就满足申请者的请求。这样申请者就可很快完成其计算，然后释放它

占用的资源，从而保证了系统中的所有进程都能完成，所以可避免死锁的发生。（计算资源的大小，计算出来后，永远按照从大到小的方式来获得锁）