笔记1
Java多线程
1.生产者消费者问题
2.死锁的产生以及解决办法
一:生产者消费者问题
实际上,准确说应该是“生产者-消费者-仓储”模型,离开了仓储,
生产者消费者模型就显得没有说服力了。对于此模型,应该明确一下几点:
- 生产者仅仅在仓储未满时候生产,仓满则停止生产。
- 消费者仅仅在仓储有产品时候才能消费,仓空则等待。
- 当消费者发现仓储没产品可消费时候会通知生产者生产。
- 生产者在生产出可消费产品时候,应该通知等待的消费者去消费。
生产者类:
import java.util.ArrayList;
import java.util.List;
public class Producer extends Thread {
private List<Integer> list = new ArrayList<>();
public Producer(List<Integer> list) {
this.list = list;
}
@Override
public synchronized void run() {
// TODO Auto-generated method stub
int i = 0;
while (true) {
while (list.size() == 5) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
list.add(i);
System.out.println("加入" + i);
i++;
}
}
}
消费者类:
import java.util.ArrayList;
import java.util.List;
public class Consumer extends Thread {
private List<Integer> list = new ArrayList<>();
public Consumer(List<Integer> list) {
this.list = list;
}
@Override
public synchronized void run() {
// TODO Auto-generated method stub
while (true) {
while (list.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
int x = list.remove(list.size() - 1);
System.out.println("消费了" + x);
}
}
}
测试类:
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
new Producer(list).start();
new Consumer(list).start();
}
}
二.死锁
1.简单描述:
进程A占有资源R1,等待进程B占有的资源Rr;进程B占有资源Rr,等待进程A占有行,若不采取其它措施,这种循环等待状况的资源R1。而且资源R1和Rr只允许一个进程占用,即:不允许两个进程同时占用。结果,两个进程都不能继续执会无限期持续下去,就发生了进程死锁。(在Java中主要存在线程死锁)
2.产生死锁的必要条件
从以上分析可见,如果在计算机系统中同时具备下面四个必要条件时,那麽会发生死锁。换句话说,只要下面四个条件有一个不具备,系统就不会出现死锁。
〈1〉临界资源使用的互斥性条件。即某个资源在一段时间内只能由一个进程占有,不能同时被两个或两个以上的进程占有。这种独占资源如CD-ROM驱动器,打印机等等,必须在占有该资源的进程主动释放它之后,其它进程才能占有该资源。这是由资源本身的属性所决定的。如独木桥就是一种独占资源,两方的人不能同时过桥。
〈2〉资源的不可抢占性条件。进程所获得的资源在未使用完毕之前,资源申请者不能强行地从资源占有者手中夺取资源,而只能由该资源的占有者进程自行释放。如过独木桥的人不能强迫对方后退,也不能非法地将对方推下桥,必须是桥上的人自己过桥后空出桥面(即主动释放占有资源),对方的人才能过桥。
〈3〉部分申请资源,占有且申请条件。进程至少已经占有一个资源,但又申请新的资源;由于该资源已被另外进程占有,此时该进程阻塞;但是,它在等待新资源之时,仍继续占用已占有的资源。还以过独木桥为例,甲乙两人在桥上相遇。甲走过一段桥面(即占有了一些资源),还需要走其余的桥面(申请新的资源),但那部分桥面被乙占有(乙走过一段桥面)。甲过不去,前进不能,又不后退;乙也处于同样的状况。
〈4〉循环等待条件。存在一个进程等待序列{P1,P2,…,Pn},其中P1等待P2所占有的某一资源,P2等待P3所占有的某一源,……,而Pn等待P1所占有的的某一资源,形成一个进程循环等待环。就像前面的过独木桥问题,甲等待乙占有的桥面,而乙又等待甲占有的桥面,从而彼此循环等待。
下面是一个死锁类:
public class Deadlock {
public static void main(String[] args) {
// 首先定义两个临界资源
final Object resource1 = "resource1";
final Object resource2 = "resource2";
Thread t1 = new Thread() {
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (resource1) {
System.out.println(Thread.currentThread().getName() + "lock" + resource1);
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (resource2) {
System.out.println(Thread.currentThread().getName() + "lock" + resource2);
}
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (resource2) {
System.out.println(Thread.currentThread().getName() + "lock" + resource2);
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (resource1) {
System.out.println(Thread.currentThread().getName() + "lock" + resource1);
}
}
}
};
t1.start();
t2.start();
}
}