线程池 线程池Jdk 5起提供了线程池相关的API：ExecutorService和ExecutorExecutorService：真正的线程池接口，常见子类：ThreadPoolExecutorvoid executor(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable Future submit(Callable task)：执行任务，有返回值，一般用来执行callablevoid shutdown()：关闭连接池Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池package com.thread.threadDemo; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @Author suaxi * @Date 2020/11/26 22:00 * 线程池 */ public class TestPool { public static void main(String[] args) { //1、创建线程池 //newFixedThreadPool 线程池大小 ExecutorService service = Executors.newFixedThreadPool(10); //2、执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //3、关闭连接 service.shutdown(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println("线程池测试"); } }

Lock（锁） Lock（锁）从Jdk5开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步（同步锁使用Lock对象充当）java.util.concurrent.locks.ReentrantLock接口是控制多个线程对共享资源进行访问的工具；锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁使用方法：class A{ //定义锁 private final ReentrantLock lock = new ReentrantLock(); public void method() { lock.lock(); //加锁 try { //保证线程安全的代码 }finally { lock.unlock(); //解锁 //如果同步代码有异常，要将unlock()写入finally语句块 } } } }购票实例：package com.thread.threadDemo; import java.util.concurrent.locks.ReentrantLock; /** * @Author suaxi * @Date 2020/11/26 18:09 * 测试Lock锁 */ public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int ticketNums = 10; //定义锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ lock.lock(); //加锁 try { if (ticketNums>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else { break; } }finally { lock.unlock(); //解锁 } } } }synchronized与Lock对比1、Lock是显示锁（手动开启和关闭）；synchronized是隐式锁，出了作用域自动释放2、Lock只有代码块锁，synchronized有代码块锁和方法锁3、使用Lock锁时，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）4、优先使用顺序：Lock --->同步代码块（已经进入了方法体，分配了相应资源） --->同步方法（在方法体之外）

线程通信 线程通信分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费对于消费者，在消费之后，要通知生产者已经消费结束，需要生产新的产品以供消费在生产者消费者问题中，仅有synchronized是不够的synchronized可阻止并发更新同一个共享资源，实现同步synchronized不能用来实现不同线程之间的消息传递（通信）应用场景：假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止如果仓库中有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止解决方式一并发协作模型“生产者/消费者模式”（管程法）生产者：负责生产数据的模块消费者：负责处理数据的模块缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区生产者将生产好的产品放入缓冲区，消费者从缓冲区拿出数据package com.thread.threadDemo; /** * @Author suaxi * @Date 2020/11/26 20:58 * 生产者消费者模型,利用缓冲区解决（管程法） */ public class TestPC01 { public static void main(String[] args) { SynContainer container = new SynContainer(); new Productor(container).start(); new Comsumer(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 Chicken(i)); System.out.println("生产了"+i+"只鸡"); } } } //消费者 class Comsumer extends Thread{ SynContainer container; public Comsumer(SynContainer container){ this.container = container; } //消费 @Override 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{ //需要一个容器大小 Chicken[] chickens = new Chicken[10]; //容器计数器 int count = 0; //生产者放入产品 public synchronized void push(Chicken chicken){ //如果容器满了，就需要等待消费者消费 if(count==chickens.length){ //通知消费者消费，生产等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有满，就需要放入产品 chickens[count] = chicken; count++; //再通知消费者消费 this.notify(); } //消费者消费产品 public synchronized Chicken pop(){ //判断能否消费 if (count==0){ //等待生产者生产，消费者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chicken chicken = chickens[count]; //吃完了，通知生产者生产 this.notify(); return chicken; } }解决方式二信号灯法package com.thread.threadDemo; /** * @Author suaxi * @Date 2020/11/26 21:40 * 测试生产者消费者问题2：信号灯法（标志位） */ public class TestPC02 { public static void main(String[] args) { TV tv = new TV(); new Player(tv).start(); new Watcher(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 Watcher extends Thread{ TV tv; public Watcher(TV tv){ this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { this.tv.watch(); } } } //产品（节目） class TV{ //演员表演，观众等待 true //观众观看，演员等待 false 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.notify(); //通知唤醒 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.notify(); this.flag = !this.flag; } }

死锁 死锁定义：多个线程互相拥抱着对方需要的资源，然后形成僵持产生死锁的四个必要条件：1、互斥：一个资源每次只能被一个进程使用2、请求与保持：一个进程因请求资源而阻塞时，对已获得的资源保持不放3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺4、循环等待：若干进程之间形成一种头尾相接的循环等待资源关系死锁实例：package com.thread.threadDemo; /** * @Author suaxi * @Date 2020/11/26 16:18 * 死锁：多个线程互相拥抱着对方需要的资源，然后形成僵持 */ public class DeadLock { public static void main(String[] args) { MakeUp p1 = new MakeUp(0, "孙笑川"); MakeUp p2 = new MakeUp(1, "药水哥"); p1.start(); p2.start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } class MakeUp extends Thread{ //需要的资源只有一份，用statick来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String name; //使用人 public MakeUp(int choice,String name){ this.choice = choice; this.name = name; } @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.name+"获得口红的锁"); Thread.sleep(1000); synchronized (mirror){ //等待一秒后想拿镜子 System.out.println(this.name+"获得镜子的锁"); } } }else { synchronized (mirror){//拿到镜子 System.out.println(this.name+"获得镜子的锁"); Thread.sleep(2000); synchronized (lipstick) { //等待两秒后想拿口红 System.out.println(this.name + "获得口红的锁"); } } } } }将choice==0中的synchronized (mirror)拿到synchronized (lipStick)之外，else中的代码同理，即可解决实例中的死锁问题package com.thread.threadDemo; /** * @Author suaxi * @Date 2020/11/26 16:18 * 死锁：多个线程互相拥抱着对方需要的资源，然后形成僵持 */ public class DeadLock { public static void main(String[] args) { MakeUp p1 = new MakeUp(0, "孙笑川"); MakeUp p2 = new MakeUp(1, "药水哥"); p1.start(); p2.start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } class MakeUp extends Thread{ //需要的资源只有一份，用statick来保证只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String name; //使用人 public MakeUp(int choice,String name){ this.choice = choice; this.name = name; } @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.name+"获得口红的锁"); Thread.sleep(1000); } synchronized (mirror){ //等待一秒后想拿镜子 System.out.println(this.name+"获得镜子的锁"); } }else { synchronized (mirror){//拿到镜子 System.out.println(this.name+"获得镜子的锁"); Thread.sleep(2000); } synchronized (lipstick) { //等待两秒后想拿口红 System.out.println(this.name + "获得口红的锁"); } } } }

线程同步 线程同步由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用释放锁即可，但同时也会带来如下问题：一个线程持有锁会导致其他所有需要此锁的线程挂起在多线程竞争下，加锁、释放锁会导致频繁的 上下文切换 和 调度延时，引起性能问题如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题同步方法synchronized关键字包括synchronized方法和synchronized块两种方法同步方法 public synchronized void method(int args){}synchronized方法控制对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行同步块同步块 synchronized（Obj）{}（Obj）{}同步监视器Obj可以是任何对象，推荐使用共享资源作为同步监视器同步方法中无须指定同步监视器，因为同步方法的同步监视器就是这个对象本身，或者是class执行过程第一个线程访问，锁定同步监视器，执行其中代码第二个线程访问，发现同步监视器被锁定，无法访问第一个线程访问完毕，释放同步监视器锁第二个线程访问，发现同步监视器没有锁，锁定并进行访问买票问题package com.thread.syn; /** * @Author suaxi * @Date 2020/11/26 14:40 * 不安全的买票，结果中出现负的票数 */ public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"孙笑川").start(); new Thread(buyTicket,"药水哥").start(); new Thread(buyTicket,"Giao哥").start(); } } class BuyTicket implements Runnable{ //票 private int ticketNums = 10; //外部停止标志 boolean flag = true; @Override public void run() { while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } //synchronized同步方法 private synchronized void buy() throws InterruptedException { //判断是否有票 if (ticketNums<=0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"买到了票"+ticketNums--); } }模拟取款package com.thread.syn; /** * @Author suaxi * @Date 2020/11/26 15:03 */ public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100, "存折"); Drawing sun = new Drawing(account, 50, "孙笑川"); Drawing yao = new Drawing(account, 100, "药水哥"); sun.start(); yao.start(); } } //账户 class Account{ int money; //余额 String name; //账户名 public Account(int money, String name) { this.money = money; this.name = name; } } //银行：模拟取款 class Drawing extends Thread{ Account account; //账户 int drawingMoney; //取款额度 int cash; //现金 public Drawing(Account account,int drawingMoney,String name){ super(name); this.account = account; this.drawingMoney = drawingMoney; } //取钱 //synchronized 默认锁的是this. @Override public void run() { //synchronized锁的对象就是变化的量，即需要增删改的对象 synchronized (account){ //判断余额 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"账户余额不足"); return; } //sleep可以放大问题的发生性 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } //余额 = 卡内余额 - 取款额度 account.money = account.money - drawingMoney; //现金 cash = cash + drawingMoney; System.out.println(account.name+"账户余额："+account.money); //继承Thread类，所以此处的this.getName() = Thread.currentThread().getName() System.out.println(this.getName()+"现金："+cash); } } }线程不安全的集合package com.thread.syn; import java.util.ArrayList; import java.util.List; /** * @Author suaxi * @Date 2020/11/26 14:59 * 线程不安全的集合 */ public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(() ->{ synchronized (list){ list.add(Thread.currentThread().getName()); } }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } } 补充：JUC安全类型的集合CopyOnWriteArrayListpackage com.thread.syn; import java.util.concurrent.CopyOnWriteArrayList; /** * @Author suaxi * @Date 2020/11/26 15:48 * 测试JUC安全类型的集合 */ public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); for (int i = 0; i < 1000; i++) { new Thread(() ->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }

守护线程 守护（Daemon）线程分为用户线程和守护线程虚拟机必须确保用户线程执行完毕虚拟机不用等待守护线程执行完毕例：后台记录操作日志，内存监控，垃圾回收等package com.thread.state; /** * @Author suaxi * @Date 2020/11/26 11:26 * 守护线程 */ public class TestDaemon { public static void main(String[] args) { God god = new God(); You you = new You(); Thread thread = new Thread(god); thread.setDaemon(true); //默认为false表示用户线程，正常的线程都是用户线程 thread.start(); //启动上帝线程 new Thread(you).start(); } } //上帝 class God implements Runnable{ @Override public void run() { while (true){ System.out.println("God bless you!"); } } } //人 class You implements Runnable{ @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("还活着！"); } System.out.println("原地去世了！"); } }

线程优先级 线程优先级Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度按照优先级来调度执行线程优先级范围：1~10Thread.MIN_PRIORITY = 1Thread.MAX_PRIORITY = 10设置方法注：1、线程优先级应先设置再启动​ 2、优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用，最终结果由CPU调度决定package com.thread.state; /** * @Author suaxi * @Date 2020/11/26 11:11 * 测试线程优先级 */ public class TestPriority { public static void main(String[] args) { //主线程默认优先级 System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority()); //设置优先级 Mypeiority mypeiority = new Mypeiority(); Thread t1 = new Thread(mypeiority); Thread t2 = new Thread(mypeiority); Thread t3 = new Thread(mypeiority); Thread t4 = new Thread(mypeiority); Thread t5 = new Thread(mypeiority); //先设置，再启动 t1.start(); t2.setPriority(3); t2.start(); t3.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY=10 t3.start(); t4.setPriority(Thread.MIN_PRIORITY); t4.start(); t5.setPriority(7); t5.start(); } } class Mypeiority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority()); } }

线程礼让 线程礼让Thread.yield();实例：package com.thread.state; /** * @Author suaxi * @Date 2020/11/25 21:31 */ public class TestYield { public static void main(String[] args) { MyYield myYield = new MyYield(); new Thread(myYield,"A").start(); new Thread(myYield,"B").start(); } } class MyYield implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"线程开始执行"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"线程执行结束"); } }注：礼让的结果最终由CPU调度决定