Java多线程（下）

死锁

多个线程各自占有一些共享资源，两个或以上线程都在等待对方释放资源，都停止执行

产生死锁的四个必要条件：

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

Lock（锁）

JUC包下的显示定义同步锁，更强大的线程同步机制

ReentrantLock类synchronized形同的并发性和内存语义

private final ReentrantLock lock = new ReentrantLock();

lock.lock();

lock.unlock();

Lock与synchronized对比

• lock是显示锁，需要手动开启关闭，synchronized是隐式锁，出了作用域自动释放
• lock只有代码锁，synchronized有代码块锁和方法锁
• 使用lock锁，JVM将花费较少的时间来调度线程，性能更好
• 优先使用顺序：lock > 同步代码块 > 同步方法

线程协作

生产者消费者模式

线程通信

Java提供了几个方法解决线程之间的通信问题

都只能在同步方法或者同步代码块中使用，否则会抛出异常

解决方法一：管程法

//管程法：利用缓冲区
public class TestPC{
  public static void mian(String[] args){
    SynContainer container = new SynContainer();
    
    new Producer(container).start();
    new Consumer(container).start();
  }
}
//生产者
class Producer extends Thread{
  SynContainer container;
  
  public Producer(SynContainer container){
    this.container = container;
  }
  
  //生产
  public void run(){
    for(int i=0; i<100; i++){
      container.push(new Chicken[i]);
      System.out.println("生产了"+i+"只鸡");
    }
  }
}
//消费者
class Consumer extends Thread{
  SynContainer container;
  
  public Consumer(SynContainer container){
    this.container = container;
  }
  
  //消费
  public void run(){
    for(int i=0 ;i<100;i++){
      System.out.println("消费了"+container.pop().id+"只鸡");
    }
  }
}
//产品
class Chicken{
  int id;
  public Chicken(int id){
    this.id = id;
  }
}
//缓冲区
class SynContainer{
  //需要一个容器大小
  chickens[] chicken = new Chicken[10];
  //容器计数器
  int count = 0;
  //生产者放入产品
  public synchronized void push(Chicken chicken){
    //如果容器满了，就需要等待消费者消费
    if(count == chicken.length){
      //通知消费者消费，生产等待
      try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
    }
    //如果没有满，需要丢入产品
    chickens[count] = chicken;
    count++;
    //通知消费者消费
    this.notifyAll();
  }
  //消费者消费产品
  public synchronuzed Chicken pop(){
    //判断能否消费
    if(count == 0){
      //通知生产者生产，消费者等待
      try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    }
    //如果可以消费
    count--;
    Chicken chicken = chickens[count];
    //通知生产者生产
		this.notifyAll();
    return chicken;
  }
}

解决方法二：信号灯法

线程池

• 背景：经常创建和销毁使用量特别大的资源，对性能影响很大
• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，实现重复利用
• 好处：
  • 提高响应速度 减少创建新线程的时间
  • 降低资源消耗 不需要每次都创建，重复利用
  • 便于线程管理

使用线程池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

public class TestPool{
  public static void main(String[] args){
    //创建服务，创建线程池
    //newFixedThreadPool参数：线程池大小
    ExecutorService service = Executors.newFixedThreadPool(10);
    
    //执行
    service.execute(new MyThread());
    service.execute(new MyThread());
    service.execute(new MyThread());
    service.execute(new MyThread());
    
    //2.关闭连接
    service.shutdown();
  }
}

class MyThread implements Runnable{
  public void run(){
    System.out.println(Thread.currentThread().getName());
  }
}

Java多线程（下）

原文：https://www.cnblogs.com/GladysJiu/p/14411402.html