Thread、Runnable、Callable
继承Thread类和 实现Runnable接口 为重点,实现Callable接口仅作了解
代码演示:
//创建线程的方式:继承Thread类 、重写run()方法、 调用start开启线程 //总结:线程开启不一定立即执行,由cpu进行调度执行 public class TestThread1 extends Thread{ //run方法线程体 @Override public void run() { for (int i = 0; i < 200; i++) { System.out.println("正在执行线程--"+i); } super.run(); } //main线程,主线程 public static void main(String[] args) { //创建一个线程对象 TestThread1 testThread1 = new TestThread1(); //调用start()方法开启线程 testThread1.start(); for (int i = 0; i < 2000; i++) { System.out.println("正在执行主方法**"+i); } } }
代码演示:
import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; //练习Thread,实现多线程同步下载图片 public class TestTheard2 extends Thread{ private String url;//图片地址 private String name;//保存的文件名 public TestTheard2(String url, String name) { this.url = url; this.name = name; } public TestTheard2() { } //下载图片的线程执行体 @Override public void run() { super.run(); WebDownloader wd = new WebDownloader(); wd.downloader(url, name); System.out.println("下载了名为:" + name + "的文件"); } public static void main(String[] args) { TestTheard2 th1 = new TestTheard2("地址1","1.jpg"); TestTheard2 th2 = new TestTheard2("地址2","2.jpg"); TestTheard2 th3 = new TestTheard2("地址3","3.jpg"); TestTheard2 th4 = new TestTheard2("地址4","4.jpg"); th1.start(); th2.start(); th3.start(); th4.start(); } } //下载器 class WebDownloader{ //下载方法 public void downloader(String url, String name){ try { FileUtils.copyURLToFile(new URL(url), new File("本地地址"+name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常,downloader方法出现问题"); } } }
代码演示:
//创建线程方式2 //实现Runnable接口,重写run方法,执行线程需要丢入Runnable接口实现类 调用start执行 public class TestThread3 implements Runnable { //run方法线程体 @Override public void run() { for (int i = 0; i < 200; i++) { System.out.println("正在执行线程--" + i); } } //main线程,主线程 public static void main(String[] args) { //1.创建Runnable接口的实现类对象 TestThread3 testThread3 = new TestThread3(); //2.创建线程对象,通过线程对象来开启我们的线程,代理 new Thread(testThread3).start(); //一步到位:new Thread(new TestThread3()).start(); for (int i = 0; i < 2000; i++) { System.out.println("正在执行主方法**" + i); } } }
继承Thread类 | 实现Runnable接口 |
---|---|
子类继承Thread类具备多线程能力 | 实现接口Runnable具有多线程能力 |
启动线程:子类对象.start(); | 启动线程:传入目标对象+Thread对象.start(); |
不建议使用:避免OOP单继承局限性 | 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用 |
发现并发问题
代码演示:
// 多个线程同时操作同一个对象 // 买火车票的例子 // 问题:多个线程同时对一个资源进行操作 (线程不安全,数据紊乱) // 模拟网络延迟:放大问题的发生性 public class TestThread4 implements Runnable { private int ticketNums = 10;//票数 @Override public void run() { while (true){ if(ticketNums <= 0){ break; } try { //模拟延迟 Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"--->拿到了第"+this.ticketNums--+"张票"); } } public static void main(String[] args) { TestThread4 ticket = new TestThread4(); new Thread(ticket, "stu").start(); new Thread(ticket, "tea").start(); new Thread(ticket, "peo").start(); } }
代码演示:
//模拟龟兔赛跑 public class Race implements Runnable { //胜利者 private static String winner; @Override public void run() { for (int i = 1; i <= 100; i++) { //模拟兔子休息 if(Thread.currentThread().getName().equals("兔子") && i%10 ==0){ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } //判断比赛是否结束 boolean flag = gameOver(i); //比赛结束就停止程序 if(flag) break; System.out.println(Thread.currentThread().getName()+"跑了" +i+ "步"); } } //判断是否完成比赛 private boolean gameOver(int steps){ //判断是否有胜利者 if(winner != null) return true; { if(steps >= 100){ winner = Thread.currentThread().getName(); System.out.println("winner is " + winner); return true; } } return false; } public static void main(String[] args) { Race race = new Race(); new Thread(race, "兔子").start(); new Thread(race, "乌龟").start(); } }
ExecutorService ser = Executors.newFixedThreadPood(1);
Future<Boolean> result = ser.submit(t1);
boolean r1 = result.get();
ser.shutdownNow();
好处:
代码演示:
//线程创建方法3,实现callable接口 public class TestCallable implements Callable<Boolean> { private String url;//图片地址 private String name;//保存的文件名 public TestCallable(String url, String name) { this.url = url; this.name = name; } public TestCallable() { } //下载图片的线程执行体 @Override public Boolean call() throws Exception { WebDownloader wd = new WebDownloader(); wd.downloader(url, name); System.out.println("下载了名为:" + name + "的文件"); return true; } public static void main(String[] args) throws Exception { TestCallable tc1 = new TestCallable("地址","1.jpg"); TestCallable tc2 = new TestCallable("地址","2.jpg"); TestCallable tc3 = new TestCallable("地址","3.jpg"); // TestCallable tc4 = new TestCallable("地址","4.jpg"); //1.创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3);//几个线程需要就定义几 //2.提交执行 Future<Boolean> r1 = ser.submit(tc1); Future<Boolean> r2 = ser.submit(tc2); Future<Boolean> r3 = ser.submit(tc3); //3.获取结果 boolean rs1 = r1.get(); boolean rs2 = r2.get(); boolean rs3 = r3.get(); //4.关闭服务 ser.shutdown(); } } //下载器 class WebDownloader{ //下载方法 public void downloader(String url, String name){ try { FileUtils.copyURLToFile(new URL(url), new File("路径"+name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常,downloader方法出现问题"); } } }
静态代理模式:
好处 :
个人结婚与婚庆公司的例子
代码演示:
//个人结婚与婚庆公司的例子 public class StaticProxy { public static void main(String[] args) { new Thread(()-> System.out.println("I love you") ).start();//lambda表达式 You you = new You("某个人"); new WeddingCompary(you).HappyMarry();//一步到位 // WeddingCompary weddingCompary = new WeddingCompary(you); // weddingCompary.HappyMarry(); } } interface Marry{ void HappyMarry(); } //真实角色 去结婚 class You implements Marry{ private String name; public You(String name) { this.name = name; } @Override public void HappyMarry() { System.out.println(this.name + "结婚了,敲开心!"); } } //代理角色 起辅助作用 class WeddingCompary implements Marry{ //代理谁 -> 真实目标角色 private Marry target; public WeddingCompary() {} public WeddingCompary(Marry target) { this.target = target; } @Override public void HappyMarry() { before(); this.target.HappyMarry();//这就是真实对象 after(); } private void after() { System.out.println("结婚之后,收钱"); } private void before() { System.out.println("结婚之前,布置婚场"); } }
为什么要使用lambda表达式
注:只有一行代码的情况下才能简化成一行;前提是接口为函数式接口(有且仅有一个抽象方法的接口)
代码演示;
//推导lambda表达式 public class TestLambda1 { //3.静态内部类 static class Like2 implements Ilike { @Override public void lambda() { System.out.println("I like lambda2"); } } public static void main(String[] args) { Ilike like = new Like(); like.lambda(); like = new Like2(); like.lambda(); //4.局部内部类 class Like3 implements Ilike { @Override public void lambda() { System.out.println("I like lambda3"); } } like = new Like3(); like.lambda(); //5.匿名内部类,没有类的名称,必须借助接口或者父类 like = new Ilike(){ @Override public void lambda() { System.out.println("I like lambda4"); } }; like.lambda(); //6.用lambda简化(重点) like = ()-> { System.out.println("I like lambda5"); }; like.lambda(); } } //1.定义一个函数式接口 interface Ilike { void lambda(); } //2.实现类 class Like implements Ilike { @Override public void lambda() { System.out.println("I like lambda"); } }
简化:
代码如下
public class TestLambda2 { public static void main(String[] args) { Ilove love = null; //1. lambda表式简化 // love = (int a)->{ // System.out.println("i love you-->" + a); // }; //简化1.参数类型 // love = (a)->{ // System.out.println("i love you-->" + a); // }; //简化2.括号 // love = a->{ // System.out.println("i love you-->" + a); // }; //简化3.去掉花括号(只能单行) love = a-> System.out.println("i love you-->" + a); love.love(520); } } interface Ilove{ void love(int a); }
创建状态、阻塞状态、死亡装填、就绪状态运行状态
线程的方法:
方法 | 说明 |
---|---|
setPriority(int new Priority) |
更改线程的优先级 |
static void sleep(long millis) |
在指定的毫秒数内让当前正在执行的线程休眠 |
void join() |
等待该线程终止 |
static void yield() |
暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() |
中断线程,别用这个方式 |
boolean isAlive() |
测试线程是否处于活动状态 |
stop()
destroy()
方法代码演示:
//标志位停止线程 public class TestStop implements Runnable { //1. 设置一个标识位 private boolean flag = true; @Override public void run() { int i = 0; while (flag) { System.out.println("run...Thread"+i++); } } //2. 设置一个公开的方法停止线程,转换标志位 public void stop(){ this.flag = false; } public static void main(String[] args) { TestStop ts = new TestStop(); new Thread(ts).start(); for (int i = 0; i < 1000; i++) { System.out.println("main" + i); if(i == 900){ //调用stop方法切换标志位,停止线程 ts.stop(); System.out.println("Thread stop"); } } } }
代码演示:
//模拟倒计时 public class TestSleep { public static void main(String[] args) { // try { // tenDown(); // } catch (InterruptedException e) { // e.printStackTrace(); // } //打印当前系统时间 Date startTime = new Date(System.currentTimeMillis()); while (true){ try { Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); startTime = new Date(System.currentTimeMillis());//更新时间 } catch (InterruptedException e) { e.printStackTrace(); } } } //模拟倒计时 public static void tenDown() throws InterruptedException { int num = 10; while(true){ Thread.sleep(1000); System.out.println(num--); if(num <= 0){ break; } } } }
代码演示:
//礼让线程 //线程礼让不一定成功 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() + "线程停止执行"); } }
代码演示:
//测试join方法,插队 public class TestJoin implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("线程插队" + i); } } public static void main(String[] args) throws InterruptedException { TestJoin join = new TestJoin(); Thread thread = new Thread(join); thread.start(); //主线程 for (int i = 0; i < 500; i++) { if(i == 200){ thread.join();//插队 } System.out.println("main" + i); } } }
线程状态。线程可以处于以下状态之一:
NEW
新生 就绪RUNNABLE
运行BLOCKED
堵塞WAITING
堵塞TIMED_WAITING
堵塞TERMINATED
终止代码演示:
//观察线程状态 public class TestState { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread( ()-> { for (int i = 0; i < 5; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("The thread is almost over"); }); //观察状态 Thread.State state = thread.getState(); System.out.println(state);//new //观察启动后 thread.start(); state = thread.getState(); System.out.println(state);//run while(state != Thread.State.TERMINATED){//线程不终止,就一直输出状态 Thread.sleep(100); state = thread.getState(); System.out.println(state); } //死亡了的线程不能再次启动 } }
Thread.MIN_PRIORITY = 1;
getPriority().setPriority(int xxx);
优先级低只是意味着获得调度的概率低,并不是高优先级必然先调用 (性能倒置问题)
代码演示:
//测试线程优先级(范围1-10) 默认为5, public class TestPriority { public static void main(String[] args) { //主线程默认优先级 System.out.println("main-->" + Thread.currentThread().getPriority()); MyPriority myPriority = new MyPriority(); Thread t1 = new Thread(myPriority, "Thread1"); Thread t2 = new Thread(myPriority, "Thread2"); Thread t3 = new Thread(myPriority, "Thread3"); Thread t4 = new Thread(myPriority, "Thread4"); Thread t5 = new Thread(myPriority, "Thread5"); Thread t6 = new Thread(myPriority, "Thread6"); Thread t7 = new Thread(myPriority, "Thread7"); //先设置优先级,再启动 t1.start(); t2.setPriority(1); t2.start(); t3.setPriority(4); t3.start(); t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10 t4.start(); t5.setPriority(Thread.MIN_PRIORITY);//MIN_PRIORITY=1 t5.start(); t6.setPriority(Thread.NORM_PRIORITY);//NORM_PRIORITY=5 t6.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); } }
守护daemon
代码演示:
//测试守护线程 上帝守护人类为例 public class TestDaemon { public static void main(String[] args) { God god = new God(); Human human = new Human(); Thread t1 = new Thread(god); t1.setDaemon(true);//默认flase代表用户线程,正常的线程都是用户线程 t1.start();//上帝守护线程启动 new Thread(human).start();//用户线程启动 } } //上帝 class God implements Runnable { @Override public void run() { while(true){//按理来说不会结束 但作为守护线程在用户线程结束后 随之结束(可能会伴随虚拟机关闭的一点点延迟) System.out.println("正在守护"); } } } //人类 class Human implements Runnable { @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("每天都要开心"); } System.out.println("goodbye world!"); } }
发生于:多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
处理多线程问题时,多线程访问一个对象,并且某些线程还想修改这个对象,这时候就需要线程同步。线程同步是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕再让下一个线程使用。
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized
,当一个线程获得对象的排它锁,独占资源,其他线程必须等待使用后释放锁即可。存在以下问题
例1:不安全购票
代码演示:
//不安全的买票 //线程不安全 有负数 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station, "买票人one").start(); new Thread(station, "买票人two").start(); new Thread(station, "黄牛").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(); } } } private void buy() throws InterruptedException { if(ticketNums <= 0){ flag = false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName() + "拿到了" + (ticketNums--) + "张票"); } }
例2:不安全取款
代码演示:
//不安全的取钱 //两个人去银行取钱 public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(100, "结婚基金"); Drawing you = new Drawing(account, 50, "你"); Drawing gf = new Drawing(account, 100, "女盆友"); you.start(); gf.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 nowMoney; public Drawing(Account account, int drawingMoney, String name){ super(name); this.account = account; this.drawingMoney = drawingMoney; } @Override public void run() { super.run(); //判断有没有钱 if(account.money - drawingMoney < 0){ System.out.println(Thread.currentThread().getName() + "钱不够,取不了"); return; } //sleep放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 取的钱 account.money -= drawingMoney; //有的钱 = 有的钱 + 取的钱 nowMoney += drawingMoney; System.out.println(account.name + "余额为:" + account.money); //this.getName() = Thread.currentThread().getName() System.out.println(this.getName() + "手里的钱:" + nowMoney); } }
例3:不安全集合
代码演示:
//线程不安全的集合 public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread( ()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是 synchronized 关键字,它包括两种用法:synchronized
方法和 synchronized
块。
锁的对象一般是变化的量,需要增删改的对象。
同步方法 public synchronized void method(int args){}
synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
缺陷:若将一个大的方法申明为synchronized,会影响效率。
只有需要修改的内容才需要锁。
同步块:synchronized(Obj){}
,Obj称之为同步监视器
同步监视器的执行过程:
支持高效率并发且是线程安全的,读操作无锁的ArrayList
代码演示:
//测试JUC安全类型的集合 public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread(() -> { list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
产生死锁的四个必要条件
避免死锁:破坏4个必要条件的之中的任意一个或多个
代码演示:
//死锁:多个线程互相有对方需要的资源,然后形成僵持 public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0, "灰姑凉"); Makeup g2 = new Makeup(1, "白雪公主"); g1.start(); g2.start(); } } //口红 class Lipstick { } //镜子 class Mirror { } class Makeup extends Thread{ //需要的资源 只有一份 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String grilName; //使用化妆品的人 Makeup(int choice, String grilName){ this.choice = choice; this.grilName = grilName; } @Override public void run() { super.run(); //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆, 互相持有对方的锁,就是需要拿到对方的资源 private void makeup() throws InterruptedException { if(choice == 0){ synchronized (lipstick){//获得口红的锁 System.out.println(this.grilName + "获得口红的锁"); Thread.sleep(1000); } synchronized(mirror){//一秒钟之后想获得镜子 System.out.println(this.grilName + "获得镜子的锁"); } }else{ synchronized (mirror){//获得镜子的锁 System.out.println(this.grilName + "获得镜子的锁"); Thread.sleep(2000); } synchronized(lipstick){//一秒钟之后想获得口红 System.out.println(this.grilName + "获得口红的锁"); } } } }
代码演示:
//测试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; //定义lock锁 ReentrantLock:可重入锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while(true){ try { lock.lock(); //加锁 if(ticketNums > 0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else{ break; } } finally { lock.unlock(); //解锁 } } } }
Lock是显示锁,需要手动开启和关闭,synchronized为隐式锁,出了作用域自动释放
lock只有代码块锁,synchronized有代码块锁和方法锁
使用lock锁,jvm将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性
优先使用顺序
Lock > 同步代码快(已经进入方法体,分配了相应资源)> 同步方法(在方法体之外)
线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件
Java提供了几个方法解决线程之间的通信问题
方法名 | 作用 |
---|---|
wait() |
表示线程一直等待,直到其他线程通知,与sleep() 不同,会释放锁 |
wait(long timeout) |
指定等待的毫秒数 |
notify() |
唤醒一个处于等待状态的线程 |
notifyAll() |
唤醒同一个对象上所有调用wait() 方法的线程,优先级别高的线程优先调度 |
注意: 均是Object类的方法,都只能在同步方法或者同步代码快中使用,否则会抛出异常 IllegalMonitorStateException
代码演示:
//测试生产者消费者模型-->利用缓冲区解决:管程法 //生产者,消费者,产品,缓冲区 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() { super.run(); for (int i = 1; i <= 100; i++) { System.out.println("生产了" + i + "只鸡"); container.push(new Chinken(i)); } } } //消费者 class Consumer extends Thread{ SynContainer container; public Consumer(SynContainer container){ this.container = container; } @Override public void run() { super.run(); for (int i = 1; i <= 100; i++) { System.out.println("消费了" + container.pop().id + "只鸡"); } } } //产品 class Chinken{ int id; //产品编号 public Chinken(int id){ this.id = id; } } //缓冲区 class SynContainer{ //需要一个容器大小 Chinken[] chinkens = new Chinken[10]; //容器计数器 int count = 0; //生产者放入产品 public synchronized void push(Chinken chinken){ //如果容器满了,就需要等待消费者消费 if(count == chinkens.length){ //通知消费者消费,生产等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果容器没满,就需要丢入产品 chinkens[count] = chinken; count++; //可以通知消费而消费了 this.notifyAll(); } //消费者消费产品 public synchronized Chinken pop(){ //判断能否消费 if(count == 0){ //等待生产者生产,消费者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chinken chinken = chinkens[count]; //吃完了,通知生产者生产 this.notifyAll(); return chinken; } }
代码演示:
//测试生产者消费者问题 //方法2:信号灯法,标志位解决 public class TestPC2 { 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() { super.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() { super.run(); for (int i = 0; i < 20; i++) { tv.watch(); } } } //产品-->节目 class TV{ //演员表演,观众等待 T //观众观看,演员等待 F String voice; //表演的节目 boolean falg = true; //表演 public synchronized void play(String voice){ if(!falg){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("演员表演了:" + voice); //通知观众观看 this.notifyAll(); //通知唤醒 this.voice = voice; this.falg = !this.falg; } //观看 public synchronized void watch(){ if(falg){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("观众观看了:" + voice); //通知演员表演 this.notifyAll(); //通知唤醒 this.falg = !this.falg; } }
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
提高响应速度(减少了创建新线程的时间)
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
便于线程管理(.…)
corePoolSize
:核心池的大小
maximumPoolSize
:最大线程数
keepAliveTime
:线程没有任务时最多保持多长时间后会终止
JDK5.0起提供了线程池相关API:ExecutorService和Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command)
:执行任务/命令,没有返回值,一般用来执行Runnable<T>Future<T>submit(Callable<T>task)
:执行任务,有返回值,一般又来执行Callablevoid shutdown()
:关闭连接池Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
代码演示:
//测试线程池 public class TestPool { public static void main(String[] args) { //1.创建服务,创建线程池 //newFixedThreadPool 参数为线程池大小 ExecutorService service = Executors.newFixedThreadPool(10); //执行 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //2.关闭连接 service.shutdown(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }
代码演示:
//回顾总结线程的创建 public class ThreadNew { public static void main(String[] args) { new MyThread1().start(); new Thread(new MyThread2()).start(); FutureTask<Integer> futureTask = new FutureTask(new MyThread3()); new Thread(futureTask).start(); try { Integer integer = futureTask.get(); System.out.println(integer); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } //1.继承Thread类 class MyThread1 extends Thread{ @Override public void run() { super.run(); System.out.println("MyThread1"); } } //2.实现Runnable接口 class MyThread2 implements Runnable{ @Override public void run() { System.out.println("MyThread2"); } } //3.实现Callable接口 class MyThread3 implements Callable<Integer>{ @Override public Integer call() throws Exception { System.out.println("MyThread3"); return 100; } }