Java study 多线程(死锁, Lock锁, 生产者消费者问题, 管程法, 信号灯法)
死锁
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
package com.smile.test.thread;
public class DeadLock {
public static void main(String[] args) {
MakeUp mk1 = new MakeUp(0, "小红");
MakeUp mk2 = new MakeUp(1, "小黑");
new Thread(mk1).start();
new Thread(mk2).start();
}
}
// 镜子对象
class Mirror{
}
// 口红对象
class LipStick{
}
// 化妆
class MakeUp implements Runnable{
static Mirror mirror = new Mirror();
static LipStick lipstick = new LipStick();
int choice; // 第一次选择的
String userName; // 化妆的人
// 有参构造
public MakeUp(int choice, String userName) {
this.choice = choice;
this.userName = userName;
}
@Override
public void run() {
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (mirror){
System.out.println(this.userName + "获得了Mirror");
Thread.sleep(1000);
synchronized(lipstick){
System.out.println(this.userName + "获得了LipStick");
}
}
}else {
synchronized (lipstick){
System.out.println(this.userName + "获得了LipStick");
Thread.sleep(1000);
synchronized(mirror){
System.out.println(this.userName + "获得了Mirror");
}
}
}
/*
不会引起死锁
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (mirror){
System.out.println(this.userName + "获得了Mirror");
Thread.sleep(1000);
}
synchronized(lipstick){
System.out.println(this.userName + "获得了LipStick");
}
}else {
synchronized (lipstick){
System.out.println(this.userName + "获得了LipStick");
Thread.sleep(1000);
}
synchronized(mirror){
System.out.println(this.userName + "获得了Mirror");
}
}
}
*/
}
}
虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。
-
互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
-
请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
-
不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
-
环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。
解决死锁:
- 只需要破坏四个必要条件任意之一, 都能避免死锁的问题.
Lock锁
- JDK5.0开始, java提供了更强大的同步机制------通过显示的定义同步锁对象来实现同步. 同步锁使用Lock对象充当.
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具. Lock锁提供了对共享资源的独立访问, 每次只能有一个线程对Lock对象加锁, 线程开始访问共享资源之前应先获得Lock对象.
- ReentrantLock是Lock 的一个实现类, 拥有与synchronized相同的并发性和内存语义, 在实际线程的安全控制中,比较常用的是ReentrantLock, 可以显示的加锁, 释放锁.
package com.smile.test.thread.unsafethread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
public class UnSafeArrayList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
ReentrantLock lock = new ReentrantLock();
for (int i = 0; i < 5000; i++) {
new Thread(()->{
lock.lock();
list.add(Thread.currentThread().getName());
lock.unlock();
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
- Lock锁是显示锁(调用lock()加锁, 调用unlock()释放锁)
- synchronized锁是隐式锁, 除了作用域自动释放.
- Lock锁只有代码块锁, synchronized有代码块锁和方法锁.
- 使用Lock锁,JVM花更少的时间调度线程, 性能更好, 并且有更好的扩展性(有很多实现类).
生产者消费者问题
管程法
package com.smile.test.thread;
/**
* 管程法
* @author 62741
*/
public class testPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Product(synContainer).start();
new Consumer(synContainer).start();
}
}
// 生产者
class Product extends Thread{
SynContainer synContainer;
public Product(SynContainer synContainer){
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
synContainer.push(new Chicken(i));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Product" + i + "Chicken");
}
}
}
// 消费者
class Consumer extends Thread{
SynContainer synContainer;
public Consumer(SynContainer synContainer){
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
synContainer.pop();
System.out.println("Consumer" + synContainer.pop().id + "Chicken");
}
}
}
class Chicken{
int id;
public Chicken(int id) {
this.id = id;
}
}
class SynContainer{
Chicken[] chickens = new Chicken[10];
int count = 0;
public synchronized void push(Chicken chicken) throws InterruptedException {
if (count == chickens.length){
// 容器满了,通知消费者消费,生产者等待
this.wait();
}
chickens[count] = chicken;
count++ ;
this.notifyAll();
}
public synchronized Chicken pop(){
if (count == 0){
// 容器空,通知生产者生产,消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
Chicken chicken = chickens[count];
this.notifyAll();
return chicken;
}
}
信号灯法
package com.smile.test.thread;
public class SingnalMothod {
public static void main(String[] args) {
Play play = new Play();
new Actor(play).start();
new Watcher(play).start();
}
}
class Actor extends Thread{
Play play;
public Actor(Play play){
this.play = play;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i%2 == 0){
play.play("第" + i + "集");
} else {
play.play("广告播放中...");
}
}
}
}
class Watcher extends Thread{
Play play;
public Watcher(Play play){
this.play = play;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
play.watch();
}
}
}
class Play{
String program;
boolean flag = true;
public synchronized void play(String program){
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Actor表演了" + program);
this.notifyAll();
this.program = program;
this.flag = !this.flag;
}
public synchronized void watch(){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Watcher看了" + program);
this.notifyAll();
this.flag = !this.flag;
}
}