死锁
多个线程各自占有一些共享资源，并且互相等待其它线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”，就可能会发生死锁的问题
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
package com.dongfangyulv.thread;
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"g1");
Makeup g2 = new Makeup(0,"g2");
g1.start();
g2.start();
}
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}
class Makeup extends Thread {
//需要的资源只有一份，用static来保证只有一份
static Mirror mirror = new Mirror();
static Lipstick lipstick = new Lipstick();
int choice;//选择
String girlName;//化妆的人
Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆，互相持有对方的锁，就是拿到对方的资源
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirror) {//一秒后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
}else {
synchronized (mirror) {//获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick) {//一秒后想获得口红
System.out.println(this.girlName + "获得口红的锁");
}
}
}
}
}
Lock锁
class A {
private final ReentrantLock lock = new ReentrantLock();
public void m() {
lock.lock();
try {
//保证线程安全的代码
}finally {
lock.unlock();
//如果同步代码有异常，要将unlock()写入finally语句块
}
}
}
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁）synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：
- Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）
线程协作
生产者消费者模式
应用场景：
- 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
- 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止
这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
- 在生产者消费者问题中仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递（通信）
- Java提供了几个方法解决线程之间的通信问题
- wait( ) 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
- wait(long timeout) 指定等待的毫秒数
- notify( ) 唤醒一个处于等待状态的线程
- notifyAll( ) 唤醒同一个对象上所有调用wait( )方法的线程，优先级别高的线程优先调度
- 均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常
- 解决方法：
- 管程法：生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
- 信号灯法
管程法
package com.dongfangyulv.senior;
//测试生产者消费者模型，利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container) {
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Apple(i));
System.out.println("生产了" + i + "个苹果");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了" + container.pop().id + "个苹果");
}
}
}
//产品
class Apple {
int id;//产品编号
public Apple(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer {
//需要一个容器大小
Apple[] apples = new Apple[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Apple apple) {
//如果容器满了，就需要等待消费者消费
if (count == apples.length) {
//通知消费者消费，生产者等待
}
//如果容器没有满，我们就需要丢入产品
apples[count] = apple;
count++;
//可以通知消费者消费了
this.notifyAll();
}
//消费者取出产品
public synchronized Apple pop() {
//判断能否消费
if (count == 0) {
//等待生产者生产，消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count--;
Apple apple = apples[count];
//通知生产者生产
return apple;
}
}
信号灯法
package com.dongfangyulv.senior;
//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Wacther(tv).start();
}
}
//生产者-->演员
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run(){
for (int i = 0; i < 20; i++) {
if (i%2==0) {
this.tv.play("节目");
}else {
this.tv.play("广告");
}
}
}
}
//消费者-->观众
class Wacther extends Thread{
TV tv;
public Wacther(TV tv){
this.tv = tv;
}
@Override
public void run(){
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
//产品-->节目
class TV {
//演员表演，观众等待 T
//观众观看，演员等待 F
String voice;//表演的节目
boolean flag = true;
//表演
public synchronized void play(String voice) {
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了：" + voice);
//通知观众观看
this.notifyAll();//通知唤醒
this.voice = voice;
this.flag = !this.flag;
}
//观看
public synchronized void watch() {
if (flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了：" + voice);
//通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
线程池
- 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用
- 好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保证多长时间后会终止
- 线程池相关API：ExecutorService和Executors
- ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor
- void execute (Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable - void shutdown( )：关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池