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

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

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

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


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