多线程中的线程通信以及死锁问题

多线程中的线程通信问题：

先列出线程中释放锁的操作：

1.当前线程的同步方法、同步代码块执行结束
2.当前线程在同步代码块，同步方法中遇到break、return、终止了该大妈快，方法的执行
3.出现了为处理的error或者exception，导致异常结束
4.当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

线程的通信使用的方法：wait()、notify()、notifyAll()----------这三个方法都是Object里的方法，不是线程中的方法

一个关于线程通信的实例：实现两个储户往同一个账户中交替存钱，每个储户存三次，每次存完打印账户中余额。

共享资源类：Account

public class Account {
    int balance;
    public Account(){}
    //synchronized:同步方法，解决线程中的安全问题
    public synchronized void saveMonny(int atm){
        notify();//唤醒其他挂起的线程
        balance += atm;
        try {
            Thread.currentThread().sleep(10);//当前线程沉睡10毫秒，放大不加同步锁时的操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+balance);
        try {
            if(balance<6000){
                wait();//账户未存满6000，当前线程挂起，并释放锁
            }else {
                //账户中存满6000，让当前线程执行结束，释放锁
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

储户类：Customer

public class Customer implements Runnable{
    Account account;    //线程中的共享资源（多个线程共同操作的对象）
    public Customer(Account account){
        this.account = account;
    }
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            account.saveMonny(1000);
        }
    }
}

测试类：

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account();
        Customer customer = new Customer(account);
        Thread t1 = new Thread(customer);
        Thread t2 = new Thread(customer);
        t1.setName("甲");
        t2.setName("乙");
        t1.start();
        t2.start();
    }
}

运行结果：

这样就利用线程通信实现了甲和乙往同一个账户中交替存钱。

线程中的死锁问题：

  什么是死锁？

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

一个死锁的实例：

public class DeadLock {
    static StringBuffer s1 = new StringBuffer();
    static StringBuffer s2 = new StringBuffer();
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){    //当前线程持s1锁，同步代码块走完则释放该锁
                    s1.append("A");
                    try {
                        Thread.currentThread().sleep(10);//当前线程沉睡10毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){  //当前线程再持一把s2锁，但被下面线程拿着，形成死锁
                        s2.append("B");
                        System.out.println(Thread.currentThread().getName()+":"+s1);
                        System.out.println(Thread.currentThread().getName()+":"+s2);
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                synchronized (s2){  //由于之前线程沉睡10毫秒，当前线程拿到s2锁
                    s1.append("C");
                    try {
                        Thread.currentThread().sleep(10);//沉睡10毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){ //需要拿到s1锁，但被上面线程拿着，形成死锁
                        s2.append("D");
                        System.out.println(Thread.currentThread().getName()+":"+s1);
                        System.out.println(Thread.currentThread().getName()+":"+s2);
                    }
                }
            }
        }.start();
    }
}

运行上面程序，会发现程序处于阻塞状态，即两个线程都在等待对方释放自己所需要的同步资源，形成死锁