多线程详解
文章目录
一、概述
基本概念
程序
是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程
是程序的一次执行过程，或是正在运行的一个程序 。是 一个动态的过程 ：有它自身的产生、存在和消亡的过程。程序是静态的，进程是动态的，进程作为资源分配的单位， 系统在运行时会为每个进程分配不同的内存区域。
多任务
多任务是在一个系统中可以同时运行多个进程。每个进程都是独立的任务，每个进程都有自己独立的内存。所谓的同时运行进程，其实是操作系统将资源分配给各个进程以后，每个进程在CPU上交替运行。
线程
进程可进一步细化为线程，是一个程序内部的一条执行径。
●若 一个进程同一时间 并行执行多个线程，就是支持多线程的。
●线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器 ( pc)，线程切换的开销小。
●每个线程，拥有自己独立的：栈、程序计数器。
●多个线程，共享同一个进程中的结构：方法区、堆。
多线程
-
什么是多线程
多线程(multithreading)，是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”(Thread)，利用它编程的概念就叫作"多线程处理"
-
原理
-
实现多线程是采用一种并发执行机制。
并发执行机制的原理：简单地说就是把一个处理器划分为若干个短的时间片，每个时间片依次轮流地执行处理各个应用程序，由于一个时间片很短，相对于一个应用程序来说，就好像是处理器在为自己单独服务一样，从而达到多个应用程序在同时进行的效果。
-
多线程就是把操作系统中的这种并发执行机制原理运用在一个程序中，把一个程序划分为若干个子任务，多个子任务并发执行，每一个任务就是一个线程。这就是多线程程序。
-
多线程技术不但可以提高交互式，而且能够更加高效，便捷的控制。在对多线程应用的时候，可以使程序响应速度得到提高，从而实现速度化、高效化的特点。另外，多线程技术存在的缺点也比较明显，需要等待比较长的时间之外，还会在一定程度上使得程序运行速度降低，使工作效率受到一定的影响，从而对资源造成了浪费。
-
-
多线程的优点
- 使用线程可以把占据时间长的程序中的任务放到后台去处理。
- 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理速度。
- 程序的运行速度可能加快。
- 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等。
- 多线程技术在IOS软件开发中也有着举足轻重的作用。
-
多线程的缺点
- 如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换。
- 更多的线程需要更多的内存空间。
- 线程可能会给程序带来更多"bug"，因此要小心使用。
- 线程的中止需要考虑其对程序运行的影响。
- 通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。
-
什么时候需要多线程
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
Process与Thread
- 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
- 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
- 注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。
核心概念
- 线程就是独立的执行路径；
- 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
- main()称为主线程，为系统的入口，用于执行整个程序；
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
- 线程会带来额外的开销，如cpu调度时间，并发控制开销。
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
二、线程创建(Thread、Runnable、Callable)
三种创建方式
1、Thread
Thread在Java API中的描述
public class Thread
extends Object
implements Runnable
线程是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。
每个线程都有优先权。 具有较高优先级的线程优先于优先级较低的线程执行。 每个线程可能也可能不会被标记为守护程序。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。
当Java虚拟机启动时，通常有一个非守护进程线程（通常调用某些指定类的名为main的方法）。 Java虚拟机将继续执行线程，直到发生以下任一情况：
-
已经调用了
Runtime类的exit方法，并且安全管理器已经允许进行退出操作。 -
所有不是守护进程线程的线程都已经死亡，无论是从调用返回到
run方法还是抛出超出run方法的run。 -
创建一个新的执行线程有两种方法。 一个是将一个类声明为
Thread的子类。 这个子类应该重写run类的方法Thread。 然后可以分配并启动子类的实例。实现步骤：
自定义线程类继承Thread类。重写run()方法，编写线程执行体。
创建线程对象，调用start()方法启动线程。
小贴士：
线程开启不一定立即执行，由CPU调度执行
-
创建方法一：
package com.ywj.lesson01; //创建线程方式一：继承Thread类，重写run()方法，调用start开启线程 public class TestThread extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在123"+i); } } public static void main(String[] args) { //main线程，主线程 //创建一个线程对象 TestThread testThread = new TestThread(); //调用start()方法开启线程 testThread.start(); for (int i = 0; i < 20; i++) { System.out.println("我在456"+i); } } }实例：下载网络图片
package com.ywj.lesson01; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; //练习Thread，实现多线程同步下载图片 public class TestThread02 extends Thread{ private String url;//网络图片地址 private String name;//保存的文件名 public TestThread02(String url,String name){ this.url = url; this.name = name; } //下载图片线程的执行体 @Override public void run() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为："+name); } public static void main(String[] args) { TestThread02 t1 = new TestThread02("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞1.jpg"); TestThread02 t2 = new TestThread02("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞2.jpg"); TestThread02 t3 = new TestThread02("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞3.jpg"); t1.start(); t2.start(); t3.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
Runnable在Java API中的描述
@FunctionalInterface
public interface Runnable
Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。
该接口旨在为希望在活动时执行代码的对象提供一个通用协议。 例如， Runnable由Thread类Thread 。 活跃的只是意味着一个线程已经启动，还没有被停止。
另外， Runnable提供了一个类被激活而不是Thread Thread类化的Thread 。 一个实现类Runnable可以在不继承运行Thread实例化一个Thread实例，并在传递本身作为目标。 在大多数情况下， Runnable接口应使用，如果你只打算重写run()方法并没有其他Thread方法。 这是重要的，因为类不应该被子类化，除非程序员打算修改或增强类的基本行为。
-
另一种方法来创建一个线程是声明实现类
Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数传递，并启动。实现步骤：
定义MyRunnable类实现Runnable接口。
实现run()方法，编写线程执行体。
创建线程对象，调用start()方法启动线程。
小贴士：
推荐使用Runnale对象，因为Java单继承的局限性
-
创建方法二：
package com.ywj.lesson01; //创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法。 public class TestThread03 implements Runnable{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在123"+i); } } public static void main(String[] args) { //创建runnable接口的实现类对象 TestThread03 testThread03 = new TestThread03(); //创建线程对象，通过线程对象来开启我们的线程，代理 new Thread(testThread03).start(); for (int i = 0; i < 20; i++) { System.out.println("我在456"+i); } } } -
小结
- 继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
- 实现Runnable接口
- 实现接口Runnalbe具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
- 继承Thread类
sleep()的使用
- 买票：
package com.ywj.lesson01;
//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread04 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()+"拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestThread04 ticket = new TestThread04();
new Thread(ticket,"peter").start();
new Thread(ticket,"jack").start();
new Thread(ticket,"黄牛").start();
}
}
-
简单案例：龟兔赛跑
- 首先来个赛道距离，然后要离终点越来越近
- 判断比赛是否结束
- 打印出胜利者
- 龟兔赛跑开始
- 故事中是乌龟赢，兔子要睡觉，所以我们来模拟兔子睡觉
- 最后，乌龟赢得比赛
package com.ywj.lesson01;
public class Race implements Runnable{
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; 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();
}
}
3、Callable(了解即可)
Callable在Java API中的描述
@FunctionalInterface
public interface Callable<V>
返回结果并可能引发异常的任务。 实现者定义一个没有参数的单一方法，称为call 。
Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。 然而，A Runnable不返回结果，也不能抛出被检查的异常。
该Executors类包含的实用方法，从其他普通形式转换为Callable类。
实施步骤
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行：Future result1 = ser.submit(t1);
- 获取结果：boolean r1 = result.get()
- 关闭服务：ser.shutdownNow();
-
创建方法三：
package com.ywj.lesson01; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; //线程创建方式三：实现callable接口 /* callable好处： 1.可以定义返回值 2.可以抛出异常 */ public class TestCallable implements Callable<Boolean>{ private String url;//网络图片地址 private String name;//保存的文件名 public TestCallable(String url,String name){ this.url = url; this.name = name; } //下载图片线程的执行体 @Override public Boolean call() { WebDownloader1 webDownloader1 = new WebDownloader1(); webDownloader1.downloader(url,name); System.out.println("下载了文件名为："+name); return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { TestCallable t1 = new TestCallable("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞1.jpg"); TestCallable t2 = new TestCallable("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞2.jpg"); TestCallable t3 = new TestCallable("https://img2.woyaogexing.com/2022/06/14/4f4b869c3cc9035f!400x400.jpg","路飞3.jpg"); //创建执行服务： ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行： Future<Boolean> result1 = ser.submit(t1); Future<Boolean> result2 = ser.submit(t2); Future<Boolean> result3 = ser.submit(t3); //获取结果： boolean r1 = result1.get(); boolean r2 = result2.get(); boolean r3 = result3.get(); System.out.println(r1); System.out.println(r2); System.out.println(r3); //关闭服务： ser.shutdownNow(); } } //下载器 class WebDownloader1 { //下载方法 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方法出现问题"); } } }
4、补充：线程池创建
背景:
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大 。
思路:
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
- 提高响应速度 ，减少了创建新线程的时间。
- 降低资源消耗 ，重复利用线程池中线程，不需要每次都创建。
- 便于线程管理。
corePoolSize ：核心池的 大小。
maximumPoolSize ：最大线程数。
keepAliveTime ：线程没有任务时最多保持多长时间后会终止。
ExecutorService ：真正的线程池接口。常见子类 ThreadPoolExecutor
★ void execute(Runnable command) ：执行任务命令，没有返回值，一般用来执行
Runnable
★ Future submit(Callable task) task)：执行任务，有返回值，一般又来执行
Callable
★ void shutdown() ：关闭连接池。
Executors ：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
★ Executors.newCachedThreadPool ()()：创建一个可根据需要创建新线程的线程池。
★ Executors.newFixedThreadPool(n )：创建一个可重用固定线程数的线程池。
★ Executors.newSingleThreadExecutor () ：创建一个只有一个线程的线程池。
★ Executors.newScheduledThreadPool(n ))：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
-
创建方法四：
class NumberThread implements Runnable{ @Override public void run() { for (int i = 0; i <=100; i++) { if (i%2==0){ System.out.println(Thread.currentThread().getName()+":"+i); } } } } class NumberThread1 implements Runnable{ @Override public void run() { for (int i = 0; i <=100; i++) { if (i%2!=0){ System.out.println(Thread.currentThread().getName()+":"+i); } } } } public class ThreadPool { public static void main(String[] args) { //1、提供指定线程池数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); //2、执行指定线程的操作。需要提供实现Runnable接口或Callable 接口实现类的对象 service.execute(new NumberThread());//适合使用于Runnable service.execute(new NumberThread1());//适合使用于Runnable //service.submit();//适合使用于Callable //3、关闭线程池 service.shutdown(); } }
三、静态代理
什么是静态代理
代理这个词是来源于Java设计模式中的代理模式，代理模式最简单的理解就是通过第三方来代理我们的工作
比如中介，房东需要将自己的房子租出去，而租客需要租房子，三者关系如此
租客租房子一般都找不到房东，房东也不会轻易将自己暴露给广大租客，因此就需要中介来充当这个中间关系
因此租客就只能通过中介来进行租房子这个工作，不需要通过房东，这就叫做代理----就是中介代理房东来处理租房子这件事情
演示：实现静态代理对比Thread
-
实例：婚庆例子
package com.ywj.lesson02; //静态代理模式总结： //真实对象和代理对象都要实现同一个接口 //代理对象要代理真实角色 /* 好处： 代理对象可以做很多真实对象做不了的事情 真实对象专注自己的事情 */ public class StaticProxy { public static void main(String[] args) { You you = new You(); new Thread( ()-> System.out.println("(๑′ᴗ‵๑)Ｉ Lᵒᵛᵉᵧₒᵤ❤") ).start(); new WeddingCompany(new You()).HappyMarry(); } } interface Marry{ void HappyMarry(); } //真实角色 class You implements Marry{ @Override public void HappyMarry() { System.out.println("你要结婚了，新郎不是我"); } } //代理角色 class WeddingCompany implements Marry{ private Marry target; public WeddingCompany(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("结婚之前，布置现场"); } }
四、Lamda表达式(JDK1.8新特性)
-
入希腊字母表中排序第十一位的字母，英语名称为Lambda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
(params)->expression【表达式】
(params)->statement【语句】
(params)->{statements}new Thread ( ()->System.out.println(“多线程学习…”)).start();
-
为什么要使用lambda表达式
- 避免匿名内部类定义过多。
- 可以让你的代码看起来很简洁。
- 去掉了一堆没有意义的代码，只留下核心的逻辑。
-
也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。
-
理解Function Interface(函数式接口)是学习Java 8 lambda表达式的关键所在。
-
函数式接口的定义：
-
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
public interface Runnable{
public abstract void run();}
-
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
-
-
Lambda基础语法
package com.ywj.lambda; /* 推导lambda表达式 */ public class TestLambda01 { //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"); } } -
Lambda语法简化
package com.ywj.lambda; /* 总结： 1.lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹 2.前提是接口为函数式接口 3.多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号 */ public class TestLambda02 { public static void main(String[] args) { //1.lambda表示简化 ILove 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); }
五、线程状态
Java中线程的状态分为6种
- 初始(NEW): 新创建了一个线程对象，但还没有调用start()方法。
- 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为"运行"。线程对象创建后，其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU使用权，此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
- 阻塞(BLOCKED)：表示线程阻塞于锁。
- 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
- 超时等待(TIME_WATING):该状态不同于WAITING,他可以在指定的时间后自行返回。
- 终止(TERMINATED)：表示该线程已经执行完毕。
这6种状态定义在Thread类的State枚举中，可以查看源码进行一一对应。
线程的状态图
状态详细说明
1.初始状态(NEW)
实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。
2、就绪状态(RUNNABLE之READY)
1. 就绪状态只能说你有资格运行，调度程序没有挑选到你，你将永远是就绪状态。
2. 调用线程的start()方法，此线程进入就绪状态。
3. 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
5. 锁池里的线程拿到对象锁后，进入就绪状态。
6. RUNNING线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
3、阻塞状态(BLOCKED)
阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
4、等待(WAITING)
处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
5、超时等待(TIMED_WAITING)
处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
6、终止状态(TERMINATED)
1. 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是他已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
2. 在一个终止的线程上调用start()方法，会抛出java.lang.lllegalThreadStateException异常。
等待队列
-
调用obj的wait(),notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
-
与等待队列相关的步骤和图解
- 线程1获取对象A的锁，正在使用对象A。
- 线程1调用对象A的wait()方法。
- 线程1释放对象A的锁，并马上进入等待队列。
- 锁池里面的对象争抢对象A的锁。
- 线程5获得对象A的锁，进入synchronized块，使用对象A。
- 线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
- notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
- 同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。
同步队列状态
- 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
- 当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
- 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
- 线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。
线程停止
-
不推荐使用JDK提供的stop()、destroy()方法。(已废弃)
-
推荐线程自己停止下来
-
建议使用一个标志位进行终止变量，如：当flag=false，则终止线程运行。
-
代码示例：
package com.ywj.lesson03; //测试Stop //1.建议线程正常停止--> 利用次数，不建议死循环 //2.建议使用标志位-->设置一个标志位 //3.不要使用JDK不建议使用的方法 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 testStop = new TestStop(); new Thread(testStop).start(); for (int i = 0; i < 1000; i++) { System.out.println("main"+i); if (i==900){ //调用stop方法切换标志位，让线程停止 testStop.stop(); System.out.println("线程该停止了"); } } } }
线程休眠
-
sleep(时间)指定当前线程阻塞的毫秒数；
-
sleep存在异常InterruptedException；
-
sleep时间达到后线程进入就绪状态；
-
sleep可以模拟网络延时，倒计时等。
-
每一个对象都有一个锁，sleep不会释放锁；
-
代码演示：计时：
package com.ywj.lesson03; //模拟倒计时 public class TestSleep02 { public static void main(String[] args) { try { tenDown(); } 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; } } } } -
打印当前系统时间
package com.ywj.lesson03; import java.text.SimpleDateFormat; import java.util.Date; //模拟倒计时 public class TestSleep02 { public static void main(String[] args) { //打印当前系统时间 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; } } } }
线程礼让
-
礼让线程，让当前正在执行的线程暂停，但不阻塞
-
将线程从运行状态转为就绪状态
-
让cpu重新调度，礼让不一定成功，看CPU调度。
-
代码示例：
package com.ywj.lesson03; //测试礼让线程 //礼让不一定成功，看CPU调度 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
-
Join合并线程，等待此线程执行完成后，再执行其他线程，其他线程阻塞
-
相当于插队
-
代码示例：
package com.ywj.lesson03; //测试Join方法，插队 public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("线程vip来了"+i); } } public static void main(String[] args) throws InterruptedException { //启动线程 TestJoin testJoin = new TestJoin(); Thread thread = new Thread(testJoin); thread.start(); //主线程 for (int i = 0; i < 500; i++) { if (i==200){ thread.join();//插队 } System.out.println("main"+i); } } }
观察测试线程的状态
- 代码示例
package com.ywj.lesson03;
//观察测试线程的状态
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("//");
});
//观察状态
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);//输出状态
}
}
}
六、线程优先级
-
现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配时间片的数量要多于优先级低的线程。设置线程优先级时，针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。在不同的JVM以及操作系统上，线程规划会存在差异， 有些操作系统甚至会忽略对线程优先级的设定。
-
我们需要值得注意的是 程序正确性不能依赖线程的优先级高低 线程的优先级只是优先级高的线程分配时间片的数量要多于优先级低的线程。
-
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行。
-
线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
-
使用以下方式改变或获取优先级
- getPriority().setPriority(int xxx)
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU调度
-
代码示例：
package com.ywj.lesson03; //测试线程的优先级 public class TestPriority { public static void main(String[] args) { //主线程默认优先级 System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); MyPriority myPriority = new MyPriority(); Thread t1 = new Thread(myPriority); Thread t2 = new Thread(myPriority); Thread t3 = new Thread(myPriority); Thread t4 = new Thread(myPriority); Thread t5 = new Thread(myPriority); Thread t6 = new Thread(myPriority); //设置优先级，在启动 t1.start(); t2.setPriority(1); t2.start(); t3.setPriority(4); t3.start(); t4.setPriority(Thread.MAX_PRIORITY); t4.start(); t5.setPriority(8); t5.start(); t6.setPriority(9); t6.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); } }
七、守护(daemon)线程
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕
-
虚拟机不用等待守护线程执行完毕
如：后台记录操作日志，监控内存，垃圾回收等待
-
其中具有代表性的就是：垃圾回收线程(守护线程)
-
守护线程的特点：一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
-
守护线程使用的地方：
- 每天0:00点系统自动备份。需要使用定时器，并且我们可以将定时器设置为守护线程。一直需要使用到定时器，没到0:00的时候就备份一次，所有的用户线程，如果结束了，守护线程就自动退出。(死循环)
-
代码示例：
package com.ywj.lesson03; //测试守护线程 //上帝守护你 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("上帝保佑你"); } } } //你 class You implements Runnable{ @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("你一生都快乐的活着"); } System.out.println("======goodbbye! world!======="); } }
八、线程同步
-
现实生活中，我们会遇到"同一个资源，多个人都想使用“的问题，比如，食堂排队打饭，每个人都要吃饭，最天然的·解决办法就是，排队，一个个来。
-
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
-
由于同一进程的多个线程共享同一快存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可.存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。
-
为什么要进行线程同步？
多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。
线程同步是指同一进程中的多个线程互相协调工作从而达到一致性。之所以需要线程同步，是因为多个线程同时对一个数据对象进行修改操作时，可能会对数据造成破坏.
-
Java并发编程包含三个基本概念
- 原子性：一（多）个操作要么全部执行要么不执行，中途不会被打断；
- 可见性：一个线程对某变量的修改对其他线程来说是可见的，即能知道值进行过修改；
- 有序性：程序执行按照代码的顺序执行；
-
队列 和 锁
线程同步形成条件：队列+锁
三大不安全案例
案例1：不安全买票
package com.ywj.syn;
//不安全的买票
//线程不安全，有负数
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"111").start();
new Thread(station,"222").start();
new Thread(station,"333").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;//外部停止方式
@Override
public void run() {
//买票
while (flag){
buy();
}
}
private void buy(){
//判断是否有票
if (ticketNums<=0){
return;
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
}
}
案例二：不安全取钱
package com.ywj.syn;
//不安全取钱
//两个人去银行取钱，账户
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"你");
Drawing girlfriend = new Drawing(account,100,"女朋友");
you.start();
girlfriend.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(){
//判断有没有钱
if (account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
return;
}
//模拟延时放大问题发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 你取的钱
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name+"余额为："+account.money);
System.out.println(this.getName()+"手里的钱："+nowMoney);
}
}
案例三：线程不安全的集合
package com.ywj.syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全集合
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(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
同步方法
-
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对提出一套机制，这套机制就是synchronized关键字，它包括两种用法：
synchronized方法和synchronized块：
同步方法：public synchronized void method(int ags){}
-
synchronized方法控制对"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷：若将一个大的方法申明为synchronized将会影响效率
同步方法弊端
- 方法里面需要修改的内容才需要锁，锁的太多，浪费资源。
同步快
-
同步快：synchronized(Obj){}
-
Obj称之为同步监视器
- Obj可以是任意对象，但是推荐使用共享资源作为同步资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[反射中的讲解]
- 同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码。
- 第二个线程访问，发现同步监视器被锁定，无效访问。
- 第一个线程访问完毕，解锁同步监视器。
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
-
案例：
案例1：线程集合
package com.ywj.syn; import java.util.ArrayList; import java.util.List; //线程不安全集合 public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ synchronized (list){ list.add(Thread.currentThread().getName()); } }).start(); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }案例2：取钱
package com.ywj.syn; //不安全取钱 //两个人去银行取钱，账户 public class UnsafeBank { public static void main(String[] args) { //账户 Account account = new Account(1000,"结婚基金"); Drawing you = new Drawing(account,50,"你"); Drawing girlfriend = new Drawing(account,100,"女朋友"); you.start(); girlfriend.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; } //取钱 //synchronized锁的是this对象 @Override public void run() { //锁的对象就是变化的量，需要增删改查的对象 synchronized (account) { //判断有没有钱 if (account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够，取不了"); return; } //模拟延时放大问题发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 你取的钱 account.money = account.money - drawingMoney; //你手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为："+account.money); System.out.println(this.getName()+"手里的钱："+nowMoney); } } }案例3：买票
package com.ywj.syn; //不安全的买票 //线程不安全，有负数 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"111").start(); new Thread(station,"222").start(); new Thread(station,"333").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(); } } } //synchonized同步方法,锁的是this private synchronized void buy()throws InterruptedException{ //判断是否有票 if (ticketNums<=0){ return; } //模拟延时 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); } }案例4：JUC安全类型集合
package com.ywj.syn; import java.util.concurrent.CopyOnWriteArrayList; //测试JUC安全类型的集合 public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); 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()); } }
死锁
-
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步快同时拥有"两个以上对象的锁"时，就可能发生"死锁"问题。
-
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用。
- 请求与保持条件：一个进程因素请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
案例：
package com.ywj.deadlock;
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
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来保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
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(锁)
-
从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前先获得Lock对象。
-
ReentrantLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock可以显示加锁、释放锁。
-
class A{ private final ReentrantLock lock = new ReenTrantLock(); public void m(){ lock.lock(); try{ //保证线程安全的代码; } finally{ lock.unlock(); //如果同步代码有异常，要将unlock()写入finally语句块 } } } -
synchronized与Lock的对比
- Lock只有代码块锁，synchronized有代码块锁和方法锁。
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序：
- Lock>同步代码块(已经进入了方法体，分配了相应资源)>同步方法(在方法体之外)
-
案例：
package com.ywj.lock; import java.util.concurrent.locks.ReentrantLock; //测试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锁 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(); } } } }
九、线程协作
线程通信
-
应用场景：生产者和消费者问题
- 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止.
- 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止.
-
分析：这是一个线程同步问题 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件.
- 对于生产者，没有生产产品之前，要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
- 在生产者消费者问题中，仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递（通信）
-
Java提供了几个方法解决线程之间的通信问题
方法名 作用 wait（） 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁 wait(long timeout) 指定等待的毫秒数 notify（） 唤醒一个处于等待状态的线程 notifyAll（） 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度 注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常lllegalMonitorStateException
-
解决方式1
-
并发协作模型“生产者/消费者模式”–>管程法
- 生产者：负责生产数据的模块(可能是方法，对象，线程，进程)；
- 消费者：负责处理数据的模块(可能是方法，对象，线程，进程)；
- 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区“；
- 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
-
代码实现：
package com.ywj.lesson08; //测试：生产者消费者模型-->利用缓冲区解决：管程法 import java.io.PrintStream; //生产者，消费者，产品，缓冲区 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 Chicken(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 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.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; } }
-
-
解决方式2
-
并发协作模型"生产者/消费者模式"–>信号灯法
-
代码实现
package com.ywj.lesson08; //测试生产者消费者问题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() { for (int i = 0; i < 20; i++) { if (i%2==0){ this.tv.play("(╥╯^╰╥)"); }else { this.tv.play("lll"); } } } } //消费者--> 观众 class Watcher extends Thread{ TV tv; public Watcher(TV tv){ this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { tv.watch(); } } } //产品-->节目 class TV{ //演员表演，观众等待 //观众观看，演员等待 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:线程没有任务时最多保持多长时间后会终止
-
JDK5.0起提供了线程池相关API:ExecutorService和Executors
-
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
- Futuresubmit(Callabletask):执行任务，有返回值，一般又来执行Callable
- void shutdown（）:关闭连接池
-
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
-
代码实现：
package com.ywj.lesson08; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //测试线程池 public class TestPool { public static void main(String[] args) { //1.创建服务，创建线程池 //参数为：线程池大小 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{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName()+i); } } }
3465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
