Day 22
2019年6月2日。
这是我学习Java的第二十二天。
这一天，我学到了以下的知识。
线程简介
线程，是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
在Java中，线程的执行如图所示：
说起线程，就必须要说到程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
线程的性质如下所述：
- 线程就是独立的执行路径；
- 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
- main（）称之为主线程，为系统的入口，用于执行整个程序；
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的；
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
- 线程会带来额外的开销，如cpu调度时间，并发控制开销。
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
线程创建
线程的创建，在Java中，具有三种方式：
-
继承Thread类
- 实现步骤：
1.自定义线程类继承Thread类
2.重写run（）方法，编写线程执行体
3.创建线程对象，调用start（）方法启动线程
- 范例如下：public class TestThread extends Thread{ //自定义run方法的线程 @Override public void run() { //线程执行体 for (int i = 0; i < 200; i++) { System.out.println("a:" + i); } } //主线程 public static void main(String[] args) { //创建线程对象 TestThread testThread1 = new TestThread1(); //调用start方法启动线程 testThread1.start(); //同时进行 for (int i = 0; i < 3000; i++) { System.out.println("b:" + i); } } } -
实现Runnable接口（常用）
- 实现步骤：
1.定义MyRunnable类实现Runnable接口
2.实现run（）方法，编写线程执行体
3.创建线程对象，调用start（）方法启动线程
- 范例如下：public class TestThread implements Runnable{ @Override public void run() { //线程执行体 for (int i = 0; i < 200; i++) { System.out.println("a:" + i); } } public static void main(String[] args) { //重点就是将runable接口实现类的对象丢入Thread构造器 TestThread testThread3 = new TestThread3(); Thread thread = new Thread(testThread3); thread.start(); for (int i = 0; i < 3000; i++) { System.out.println("b:" + i); } } } -
实现Callable接口
- 实现步骤：
1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5.提交执行：Future<Boolean.> result = ser.submit(t1);
6.关闭服务：ser.shutdownNow();
- 范例如下：public class Demo4Thread implements Callable<Boolean> { @Override public Boolean call() throws Exception { return false; } public static void main(String[] args) { Demo4Thread demo4Thread = new Demo4Thread(); ExecutorService ser = Executors.newFixedThreadPool(1); Future<Boolean> result1 = ser.submit(demo4Thread); } } -
继承Thread类和实现Runnable接口的区别
- 继承Thread类
1.子类继承Thread类具备多线程能力
2.启动线程：子类对象.start()
3.不建议使用：避免OOP单继承局限性
- 实现Runnable接口
1.实现接口Runnable具有多线程能力
2.启动线程：传入目标对象+Thread对象.start()
3.推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
线程范例：龟兔赛跑
需求：模仿“龟兔赛跑”的故事，在Java中用两个线程来实现
分析：
- 龟兔赛跑开始
- 故事中是乌龟赢的，兔子需要睡觉，所以要模拟兔子睡觉
- 首先定义赛道距离，然后乌龟离赛道终点越来越近
- 判断比赛是否结束
- 最终，乌龟赢得比赛
- 打印出胜利者
代码如下：
public class Race implements Runnable{
//winner:只有一个胜利者
private static String winner;
@Override
public void run() {
//赛道
for (int step = 1; step <= 101; step++) {
//模拟兔子休眠
if (Thread.currentThread().getName().equals("兔子") && step % 50 ==0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(step);
if (flag){
break;
}
System.out.println( Thread.currentThread().getName() + "跑了" + step +"步");
}
}
//判断比赛是否结束
private boolean gameOver(int step){
if (winner != null){ // 如果存在胜利者
return true;
}
if (step >= 100){ // 如果跑到了终点
winner = Thread.currentThread().getName();
System.out.println("比赛结束");
System.out.println("胜利者--->" + winner);
return true;
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
线程状态
线程的状态，在Java中，共具有5种，如图所示：
线程的状态转换，如图所示：
线程方法
在Java中，线程类里存在一些特定的方法，可以对线程进行管理，如下所示：
-
线程停止
虽然线程类中提供了stop（）方法和destroy（）方法，但是不推荐使用，而是推荐线程自己停止下来。
若想要线程自行停止，建议使用一个标志位充当终止变量，当flag=false，则终止线程运行。 -
线程休眠（sleep）
- sleep（时间）指定当前线程阻塞的毫秒数；
- sleep存在异常InterruptedException；
- sleep时间达到后线程进入就绪状态；
- sleep可以模拟网络延时，倒计时等‘’
- 每一个对象都有一个锁，sleep不会释放锁；
用线程休眠来模拟系统时间并且让时间流动，示例如下：
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
TestSleep2 testSleep2 = new TestSleep2();
//获取系统时间
Date startTime = new Date(System.currentTimeMillis());
while (true) {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
Thread.sleep(1000);
startTime = new Date(System.currentTimeMillis());
}
}
//倒计时方法
private void tenDown() throws InterruptedException {
int num = 10;
for (int i = 10; i > 0; i--) {
Thread.sleep(1000);
System.out.println("倒计时:"+i);
}
}
}
-
线程礼让（yield）
- 礼让线程，让当前正在执行的线程暂停，但不阻塞；
- 将线程从运行状态转为就绪状态；
- 让cpu重新调度，礼让不一定会成功！
示例如下：
public class TestYield {
public static void main(String[] args) throws InterruptedException {
MyYield myYield = new MyYield();
new Thread(myYield,"小明").start();
new Thread(myYield,"老师").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可以插入线程，当该线程执行完毕后，再执行其他线程（其他线程之前会阻塞）；
- join与现实世界的插队类似；
示例如下：
public class TestJoin implements Runnable{
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
for (int i = 0; i < 100; i++) {
if (i==80){
//强制执行
thread.join();
}
System.out.println("我是主线程:"+i);
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("我是要插队的线程:"+i);
}
}
}
-
线程状态观测（State）
通过Thread.State（）方法，可以查看线程当前的状态。
线程的状态，有以下几种：- NEW
尚未启动的线程处于此状态 - RUNNABLE
在Java虚拟机中执行的线程处于此状态 - BLOCKED
被阻塞等待监视器锁定的线程处于此状态 - WAITING
正在等待另一个线程执行特定动作的线程处于此状态 - TIMED WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态 - TERMINATED
已退出的线程处于此状态
一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟机状态
实例如下： - NEW
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);
System.out.println(Thread.currentThread().getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
}
- 线程优先级（priority）
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
- 线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- 使用这些方式可以改变（setPriority）或者获取优先级（getPriority）
示例如下：
public class TestPriority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread thread1 = new Thread(myPriority);
Thread thread2 = new Thread(myPriority);
Thread thread3 = new Thread(myPriority);
Thread thread4 = new Thread(myPriority);
Thread thread5 = new Thread(myPriority);
thread1.setPriority(1);
thread1.start();
thread2.setPriority(4);
thread2.start();
thread3.setPriority(8);
thread3.start();
thread4.setPriority(9);
thread4.start();
thread5.setPriority(10);
thread5.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();
Thread thread = new Thread(god);
thread.setDaemon(true); //设置线程为守护线程,默认为false
thread.start();
//用户线程
new Thread(()->{
for (int i = 0; i < 30; i++) {
System.out.println("你开心的在这个世界上活着"+i);
}
System.out.println("=======Goodbye , World!");
}).start();
}
}
//守护线程
class God implements Runnable{
@Override
public void run() {
for (;true;){
System.out.println("上帝保佑着你");
}
}
}
线程同步
若多个线程操作同一个资源，可能会出现线程不安全的情况。
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步实质上就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
由于同一个进程的多个线程共享同一块存储空间，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。该机制会带来以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
同步方法（并发问题一）
- 由于可以通过private关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
同步方法:public synchronized void method(int args){} - synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，并继续执行（缺陷：若将一个大的方法申明为synchronized，将会影响效率）
假设同时有三个人在买票，票数总共有10张，若不添加同步关键字，则会出现线程不安全的问题（即会出现一张票被同时买到的情况）示例如下：
1.不安全情况
public class UnsafeBuyTicket implements Runnable {
//票数
private int ticketNums = 10;
//标志位
private boolean flag = true;
@Override
public void run() {
//买票
while (flag) {
buyTicket();
}
}
public void buyTicket() {
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟网络延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
}
public static void main(String[] args) {
UnsafeBuyTicket station = new UnsafeBuyTicket();
new Thread(station,"苦逼的我").start();
new Thread(station,"牛逼的你们").start();
new Thread(station,"可恶的黄牛党").start();
}
}
2.安全情况（加入同步方法）
public class SafeBuyTicket implements Runnable {
//票数
private int ticketNums = 10;
//标志位
private boolean flag = true;
@Override
public void run() {
//买票
while (flag) {
buyTicket();
}
}
//同步方法,关键词synchroinzed.
//关键字是锁
//实现的机制是队列
//还能所反射的那个class
public synchronized void buyTicket() {
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟网络延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
}
public static void main(String[] args) {
SafeBuyTicket station = new SafeBuyTicket();
new Thread(station,"苦逼的我").start();
new Thread(station,"牛逼的你们").start();
new Thread(station,"可恶的黄牛党").start();
}
}
同步块（并发问题二）
- 格式：
synchronized(Obj obj){}，Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class - 同步监视的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码；
- 第二个线程访问，发现同步监视器被锁定，无法访问；
- 第一个线程访问完毕，解锁同步监视器；
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
假设同时有两个人在银行取钱，若不添加同步关键字，则会出现线程不安全的问题（即会出现第一个人把存款取完，在银行存款还没有及时刷新时，第二个人再次取款，则会让银行存款变为负数）示例如下：
1.不安全情况
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100,"招商卡");
Bank you = new Bank("痛苦的你",account,50);
Bank wife = new Bank("开心的媳妇",account,100);
you.start();
wife.start();
}
}
//账户
class Account{
int money;//余额
String name; //卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行
class Bank extends Thread{
//存钱:存了多少,取钱:取了多少
Account account; //账户
int drawingMoney; //取了多少钱
int nowMoney; //手里有多少钱
public Bank(String name,Account account,int drawingMoney){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
//判断能否取钱
if (account.money-drawingMoney<0){
return;
}
//为了放大问题发生性,我们加个延时.
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//余额 = 余额 - 你去走的钱
account.money = account.money - drawingMoney;
//你的钱 = 你的钱 + 你取的钱
nowMoney = drawingMoney + nowMoney;
System.out.println(this.account.name+"账户余额:"+account.money);
System.out.println(this.getName()+"手里的钱:"+nowMoney);
}
}
2.安全情况（同步块）
public class SafeBank {
public static void main(String[] args) {
Account2 account = new Account2(100,"招商卡");
Bank2 you = new Bank2("痛苦的你",account,50);
Bank2 wife = new Bank2("开心的媳妇",account,100);
you.start();
wife.start();
}
}
//账户
//实体类
class Account2{
int money;//余额
String name; //卡名
public Account2(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行
class Bank2 extends Thread{
//存钱:存了多少,取钱:取了多少
Account2 account; //账户
int drawingMoney; //取了多少钱
int nowMoney; //手里有多少钱
public Bank2(String name,Account2 account,int drawingMoney){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
drwaing();
}
//synchronized本身锁的是this.就是这个对象本身
public void drwaing(){
//提高性能的代码
if (account.money<=0){
return;
}
//如何判断锁的对象
// 谁需要实现增删改就去锁定他
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 = drawingMoney + nowMoney;
System.out.println(this.account.name+"账户余额:"+account.money);
System.out.println(this.getName()+"手里的钱:"+nowMoney);
}
}
}
List（并发问题三）
因为List并非是线程安全的，所以同样需要用synchronized来令List线程的线程安全。
示例如下：
1.不安全情况
public class UnSafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 20000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
for (int i = 5;i>0;i--){
Thread.sleep(1000);
System.out.println("倒计时"+i);
}
System.out.println(list.size());
}
}
2.安全情况（同步关键字）
public class SafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
for (int i = 5;i>0;i--){
Thread.sleep(1000);
System.out.println("倒计时"+i);
}
System.out.println(list.size());
}
}
线程死锁
- 概念：多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行。而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题
- 产生死锁的必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系
解决死锁
上面列出的死锁的四个必要条件，只要想办法破坏其中的任意一个或多个条件，就可以避免死锁发生
假设有两个女生，在出门之前同时进行化妆（需要拿镜子和口红），若一个女生先拿到镜子，另一个女生先拿到口红，之后，为了得到彼此的口红和镜子，两方都需要等待，就会发生死锁，示例如下：
1.不安全情况
public class DeadLocked {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"白雪公主");
Makeup g2 = new Makeup(1,"灰姑凉");
new Thread(g1).start();
new Thread(g2).start();
}
}
//化妆
class Makeup implements Runnable{
//选择
int choice;
//谁进来了
String girlName;
//两个对象
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
public Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆的方法
public void makeup() throws InterruptedException {
if (choice==0){ //先拿口红,再拿镜子
synchronized (lipStick){
System.out.println("拿到口红");
Thread.sleep(1000);
//等待拿镜子的人释放锁
synchronized (mirror){
System.out.println("拿到镜子");
}
}
}else { //先拿镜子 , 再拿口红
synchronized (mirror){
System.out.println("拿到镜子");
Thread.sleep(2000);
//等待拿口红的人释放锁
synchronized (lipStick){
System.out.println("拿到口红");
}
}
}
}
}
2.安全情况（避免synchronized块嵌套）
public class DeadLocked {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"白雪公主");
Makeup g2 = new Makeup(1,"灰姑凉");
new Thread(g1).start();
new Thread(g2).start();
}
}
//化妆
class Makeup implements Runnable{
//选择
int choice;
//谁进来了
String girlName;
//两个对象
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
public Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆的方法
public void makeup() throws InterruptedException {
if (choice==0){ //先拿口红,再拿镜子
synchronized (lipStick){
System.out.println("拿到口红");
Thread.sleep(1000);
//等待拿镜子的人释放锁
}
synchronized (mirror){
System.out.println("拿到镜子");
}
}else { //先拿镜子 , 再拿口红
synchronized (mirror){
System.out.println("拿到镜子");
Thread.sleep(2000);
//等待拿口红的人释放锁
}
synchronized (lipStick){
System.out.println("拿到口红");
}
}
}
}
//口红
class LipStick{
}
//镜子
class Mirror{
}
Lock（锁）
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
- ReentranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
示例如下：
public class TestLock {
public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
new Thread(helloWorld).start();
new Thread(helloWorld).start();
}
}
class HelloWorld implements Runnable{
int ticketNums = 100;
//可重入锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock(); //加锁
//判断是否有票
if (ticketNums>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else {
break;
}
} finally {
lock.unlock();//解锁
}
}
}
}
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：
- Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）
线程协作——生产者消费者模式
-
应用场景：生产者和消费者问题
- 假设仓库只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
- 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止 -
分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
- 在生产者消费者问题中，仅有synchronized是不够的：
1.synchronized可阻止并发更新同一个共享资源，实现了同步
2.但synchronized不能用来实现不同线程之间的消息传递（通信） -
线程方法：针对线程之间互相通信的问题，Java提供了几个方法用于解决
-wait()：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
-wait(long timeout)：指定等待的毫秒数
-notify()：唤醒一个处于等待状态的线程
-notifyall()：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
注意：以上的均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegaIMonitorStateException
解决方式：针对生产者/消费者模式的问题，有两种方法可以解决
- 管程法
- 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）；
- 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）；
- 缓冲区：消费者不能直接使用生产者的数据，它们之间有一个缓冲区
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
示例如下：
//思路
//1.思考需要哪些对象?
// 生产 , 消费 , 产品 , 容器
//2.分工
/*
生产者只管生产
消费者只管消费
鸡: 实体类
容器 :
容器添加数据.
要判断容器是否满 , 满了等待消费者消费
没有满,通知生产者生产
容器减少数据
判断还有没有数据, 没有数据的话 . 等待生产者生产
消费完毕 , 通知生产者生产
*/
import java.sql.SQLOutput;
//测试生产者和消费者问题
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
//生产者
class Productor extends Thread{
//需要向容器中加入产品
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 1; 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 = 1; i < 100; i++) {
//消费者拿走产品
Chicken chicken = container.pop();
System.out.println("消费者消费了"+chicken.id+"鸡");
}
}
}
//缓冲区-->容器
class SynContainer{
//容器
Chicken[] chickens = new Chicken[10];
//容器的计数器
int num = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//假如容易已经满了,就不用放,等待消费者消费
if (num>=chickens.length){
//等待消费者消费
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//假如容器没有满 , 通知生产生成
System.out.println("num,,,,,"+num);
chickens[num] = chicken;
System.out.println("数组有多少个元素"+num);
num++;
//通知消费者消费
this.notifyAll();
}
//消费者拿走产品
public synchronized Chicken pop(){
//假如容器空的,等待
if (num<=0){
//等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num--;
Chicken chicken = chickens[num];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
//产品->鸡
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
}
-
信号灯法
在产品中设置一个标志位，利用标志位（flag）来选择让生产者执行逻辑还是让消费者执行逻辑（类似于红灯停，绿灯行）示例如下：
//生产者消费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("节目:快乐大本营播放中");
System.out.println();
}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++) {
tv.watch();
}
}
}
//电视
class TV{
//演员说话 , 观众等待
//观众观看 , 演员等待
boolean flag = true;
//说话
String voice;
//表演
public synchronized void play(String voice){
//演员等待
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("表演了"+voice);
this.voice = voice;
//让观众观看
this.notifyAll();
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：线程没有任务时最多保持多长时间后终止 - 使用线程池：JDK 5.0起提供了线程池相关API：ExecutorService和Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- <T.>Future<T.> submit(Callable<T.> task)：执行任务，有返回值，一般用来执行Callable
- void shutdown()：关闭线程池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
示例：
public class ThreadPool{
public static void main(String[] args) {
//创建一个线程池(池子大小)
ExecutorService pool = Executors.newFixedThreadPool(10);
//执行runnable接口实现类
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
//关闭连接池
pool.shutdown();
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
System.out.println("MyThread4");
}
}
1185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
