什么是进程？什么是线程?
对于java程序来说，当在DOS命令窗口中输入
进程和线程是什么关系？举个例子
注意：
进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！）
线程A和线程B呢？
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
火车站，可以看做是一个进程。火车站中的每一个售票窗口可以看做是一个线程。我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。所以多线程并发可以提高效率。
java中之所以有多线程机制，目的就是为了提高程序的处理效率。
思考：使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束。main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。
分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？
/*
分析以下程序有几个线程？除了垃圾回收器之外。有几个线程？
1个线程，（因为程序只有一个栈）
*/
public class ThreadTest01 {
public static void main(String[] args) {
System.out.println("main begin");
m1();
System.out.println("main end");
}
private static void m1() {
System.out.println("m1 begin");
m2();
System.out.println("m1 end");
}
private static void m2() {
System.out.println("m2 begin");
m3();
System.out.println("m2 end");
}
private static void m3() {
System.out.println("m3 execute!");
}
}
/*
运行结果：
main begin
m1 begin
m2 begin
m3 execute!
m2 end
m1 end
main end
*/
java.lang.Thread，重写run方法。myThread.run();//不会启动线程，不会分配新的分支栈（这种方式就是单线程）// 定义线程类
public class MyThread extends Thread{
public void run(){
}
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();
public class ThreadTest02 {
public static void main(String[] args) {
// 这里是main方法，这里的代码属于主线程，在主栈中运行
// 新建一个分支线程对象
MyThread myThread = new MyThread();
// 启动线程
myThread.start();
/*
start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了
这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。
启动成功的线程会自动调用run()方法，并且run()方法在分支栈的栈底部（压栈）。
run()方法在分支栈的栈底部，main()方法在主栈的栈底部，run和main是平级的。
*/
// 下面的代码还是运行在主线程中
for (int i = 0; i < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
class MyThread extends Thread {
@Override
public void run() {
// 编写程序，下面这段程序运行在分支线程中（分支栈）
for (int i = 0; i < 10; i++) {
System.out.println("分支线程 --->" + i);
}
}
}
java.lang.Runnable接口，实现run方法。// 定义一个可运行的类
public class MyRunnable implements Runnable {
public void run(){
}
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();
public class ThreadTest03 {
public static void main(String[] args) {
// 创建一个可运行的对象
MyRunnable r = new MyRunnable();
// 将可运行的对象封装成一个线程对象
Thread t = new Thread(r);
// 启动线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
//这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("分支线程 --->" + i);
}
}
}
public class ThreadTest04 {
public static void main(String[] args) {
// 创建线程对象，采用匿名内部类的方式
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("分支线程--->" + i);
}
}
});
// 启动线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
static Thread currentThread();public class ThreadTest05 {
public static void main(String[] args) {
// currentThread就是当前线程对象
// 这个代码出现在main方法当中，所以当前线程就是主线程。
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName());//main
// 创建线程对象
MyThread2 t = new MyThread2();
// 设置线程的名字
t.setName("t1");
// 获取线程的名字
String tName = t.getName();
System.out.println(tName);//ttt
MyThread2 t2 = new MyThread2();
t2.setName("t2");
System.out.println(t2.getName());
t2.start();
// 启动线程
t.start();
}
}
class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
// currentThread就是当前线程对象，当前线程对象是谁？
// 当t1线程执行run()方法,那么这个当前的线程就是t1
// 当t2线程执行run()方法,那么这个当前的线程就是t2
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "--->" + i);
}
}
}
String name = 线程对象.getName();public class ThreadTest05 {
public static void main(String[] args) {
// 创建线程对象
MyThread2 t = new MyThread2();
// 设置线程的名字
t.setName("ttt");
// 获取线程的名字
String tName = t.getName();
System.out.println(tName);//ttt
// 启动线程
t.start();
}
}
class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("分支线程 --->" + i);
}
}
}
线程对象.setName("线程名字")public class ThreadTest05 {
public static void main(String[] args) {
// 创建线程对象
MyThread2 t = new MyThread2();
// 设置线程的名字
t.setName("ttt");
// 启动线程
t.start();
}
}
class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("分支线程 --->" + i);
}
}
}
static void sleep(long millis);Thread.sleep(1000); 。参数是毫秒。public class ThreadTest06 {
public static void main(String[] args) {
// 让当前线程进入休眠，休眠5秒钟
// 当前线程是主线程
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒钟之后执行这里的代码
System.out.println("hello world");
}
}
Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。public class ThreadTest06 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
// 睡眠1秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Thread.sleep()方法的一个问题public class ThreadTest07 {
public static void main(String[] args) {
Thread t = new MyThread3();
t.setName("t");
t.start();
// 调用sleep()方法
try {
// 问题：这行代码会让线程t进入休眠状态吗
t.sleep(1000 * 5);
/*
这行代码在执行的时候还是会转换成：Thread.sleep(1000*5);
这行代码的作用：让当前线程进入休眠，也就是说main线程进入休眠。
这样代码出现在main方法中，main线程休眠
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello world");
}
}
class MyThread3 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable2());
t.setName("t");
t.start();
// 希望5秒之后，t线程醒来
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终断线程的睡眠（这种终断睡眠的方式依靠了Java的异常处理机制）
t.interrupt();//干扰
}
}
class MyRunnable2 implements Runnable {
/*
重点：run()方法当中的异常不能throws，只能try...catch
因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常
*/
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--->begin");
// 睡眠1年
try {
Thread.sleep(1000 * 60 * 60 * 24 * 365);
} catch (InterruptedException e) {
// 打印异常信息
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "--->end");
}
}
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable3());
t.setName("t");
t.start();
// 模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒之后强行终止t线程
t.stop();//已过时（不建议使用）
}
}
class MyRunnable3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadTest10 {
public static void main(String[] args) {
MyRunnable4 r = new MyRunnable4();
Thread t = new Thread(r);
t.setName("t");
t.start();
// 模拟5秒
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止线程
// 想要什么时候终止t,那么把标记修改为false就结束了
r.run = false;
}
}
class MyRunnable4 implements Runnable {
// 打个布尔标记
boolean run = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (run) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
// return就结束了，在结束之前还有什么没有保存的，在这里可以保存。
// 终止当前线程
return;
}
}
}
}
常见的线程调度模型有哪些？
java中提供了哪些方法是和线程调度有关系的呢？
实例方法：
void setPriority(int newPriority) 设置线程的优先级。int getPriority() 获取线程优先级。最低优先级1。默认优先级是5。最高优先级10。优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）静态方法：static void yield() 让位方法暂停当前正在执行的线程对象，并执行其他线程yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。注意：在回到就绪之后，有可能还会再次抢到。
实例方法：
void join()
合并线程
class MyThread1 extends Thread {
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
}
}
class MyThread2 extends Thread{
}
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*
运行结果:
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额5000.0
*/
/*
银行账户
*/
public class Account {
private String actno;
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 循环的方法
public void withdraw(double money) {
// t1和t2并发这个方法，（t1和t2是两个不同的栈，两个不同的栈操作堆中同一个对象）
// 取款之前的余额
double before = this.getBalance();
// 取款之后的余额
double after = before - money;
// 在这里模拟以下网络延迟,一定会出现问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 更新余额
// 思考：t1执行到这里了，但还没来得及执行下面这行代码，t2线程进来withdraw方法了，此时一定会出现问题。
this.setBalance(after);
}
}
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
@Override
public void run() {
// run方法的执行表示取款操作
// 假设取款5000
double money = 5000;
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，余额" + act.getBalance());
}
}
public class Test1 {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*
运行结果:
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额0.0
*/
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
@Override
public void run() {
// run方法的执行表示取款操作
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发这个程序
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，余额" + act.getBalance());
}
}
/*
银行账户
使用线程同步机制，解决线程安全问题
*/
public class Account {
private String actno;
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 循环的方法
public void withdraw(double money) {
// 以下者几行代码必须是线程排队的,不能并发
// 一个线程把这里的代码全部执行完毕之后,另一个线程才能进来
/*
线程同步机制的语法
synchronized(){
//线程同步代码块
}
synchronized后面小括号中传的这个"数据"是相当关键的.
这个数据必须是多线程共享的数据.才能达到多线程排队.
()中写什么?
那要看你想让哪些代码块同步
假设t1,t2,t3,t4,t5,有5个线程.
你只希望t1,t2,t3排队,t4,t5不需要排队,该怎么办?
一定要在()中写一个t1,t2,t3共享的对象,而这个对象对于t4,t5来说不是共享的.
这里的共享对象是:账户对象
账户对象是共享的,那么这里的this是账户对象.
不一定是this,这里只要是多线程共享的那个对象就行.
在Java语言中,任何一个对象都有"一把锁",其实这把锁就是标记(只是把它叫做??)
100个对象,100把锁,1个对象1把锁.
以下代码的执行原理
1.假设t1和t2线程并发,开始执行以下代码的时候,肯定有一个先一个后.
2.假设t1先执行了,遇到synchronized,这个时候自动找"后面共享对象"的对象锁,
找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一致都是占有这把锁,
直到同步代码块代码结束,这把锁才会释放.
3.假设t1已经占有这把锁,此时t2也遇到了synchronized关键字,也会去占有后面共享对象的这把锁,
如果这把锁被t1占有,t2只能在同步代码块的外面等待t1的结束,直到t1把同步代码块执行结束了,
t1会归还这把锁,此时t2终于等到这把锁,然后t2占有这把锁之后,进入同步代码块执行程序.
这样就达到了线程排队执行
这里需要注意的是:这个共享对象一定要选好了.这个共享对象一定是你需要排队执行的这些线程所共享的.
*/
synchronized (this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*
运行结果:
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额5000.0
*/
public class Account {
private String actno;
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 循环的方法
/*
在实例方法上可以使用synchronized,synchronized出现在是实例方法上,一定锁得是this
没得挑,只能是this.不能是其他对象,所以这种方式不灵活
*/
public synchronized void withdraw(double money) {
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
@Override
public void run() {
// run方法的执行表示取款操作
// 假设取款5000
double money = 5000;
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功，余额" + act.getBalance());
}
}
synchronized(线程共享对象){
同步代码块;
}
StringBuilder。因为局部变量不存在线程安全问题。选择StringBuilder。StringBuffer效率比较低。ArrayList是非线程安全的。Vector是线程安全的。HashMap HashSet是非线程安全的。Hashtable是线程安全的。
死锁代码要会写。只有会写的,才会在以后的开发中注意这个事.因为死锁很难调试。
synchronized在开发中中最好不要嵌套使用，一不小心就可能导致死锁现象的发生。
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
// t1和t2两个线程共享o1和o2
Thread t1 = new MyThread1(o1, o2);
Thread t2 = new MyThread2(o1, o2);
t1.start();
t2.start();
}
}
class MyThread1 extends Thread {
Object o1;
Object o2;
public MyThread1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2) {
}
}
}
}
class MyThread2 extends Thread {
Object o1;
Object o2;
public MyThread2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1) {
}
}
}
}
synchronized。不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。/*
守护线程
*/
public class ThreadTest14 {
public static void main(String[] args) {
Thread t = new BakDataThread();
t.setName("备份数据的线程");
// 启动线程之前，将线程设置为守护线程
t.setDaemon(true);
t.start();
// 主线程“主线程是用户线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread {
@Override
public void run() {
int i = 0;
// 即使是死循环，但是由于该线程是守护者，当用户线程结束，守护线程自动终止
while (true) {
System.out.println(Thread.currentThread().getName() + "--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。/*
使用定时器指定定时任务
*/
public class TimerTest {
public static void main(String[] args) throws Exception {
// 创建定时器对象
Timer timer = new Timer();
// Timer timer=new Timer(true);//守护线程的方式
// 指定定时任务
// timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-07-11 07:12:00");
timer.schedule(new LogTimerTask(), firstTime, 1000 * 10);
}
}
//编写一个定时任务类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {
@Override
public void run() {
// 在这里编写需要执行的任务
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime + ":成完成了一次数据备份！");
}
}
public class ThreadTest15 {
public static void main(String[] args) throws Exception {
// 第一步创建一个“未来任务类”对象
// 参数非常重要，需要给一个Callable接口实现类对象
FutureTask task = new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
/*
call()方法相当于run()方法，只不过这个有返回值，
线程执行一个任务之后可能会有一个执行结果。
*/
// 模拟执行
System.out.println("call method begin!");
Thread.sleep(1000 * 10);
System.out.println("call method end!");
int a = 100;
int b = 200;
return a + b;//自动装箱（300结果变成Integer）
}
});
// 创建线程对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 这里是main方法，是主线程
// get()方法的执行会导致“当前线程阻塞”
Object obj = task.get();
System.out.println("线程执行结果：" + obj);
/*
main方法这里的程序要执行必须等待get()方法结束。
而get()方法可能需要很久，因为get()方法是为了拿到另一个线程的执行结果。
另一个线程执行是需要时间的。
*/
System.out.println("hello world");
}
}
/*
运行结果：
call method begin!
call method end!
线程执行结果：300
hello world
*/
wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。wait方法和notify方法不是通过线程对象调用，不是这样的：t.wait()，也不是这样的：t.notify()..不对。
wait()方法作用？
Object o = new Object();
o.wait();
/*
表示：
让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。
o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
*/
notify()方法作用？
Object o = new Object();
o.notify(); //唤醒正在o对象上等待的线程。
notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。wait()方法和notify()方法实现“生产者和消费者模式”wait()方法和notify()方法。wait()方法和notify()方法不是线程对象的方法，是普通Java对象都有的方法。wait()方法和notify()方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。wait()方法的作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。notify()方法的作用：o.notify()把正在o对象上等待的线程唤醒，只是通知，不会释放o对象之前占有的锁。
//生产线程
class Producer implements Runnable {
// 仓库
private List list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直生产(使用死循环来模拟一直生产)
while (true) {
synchronized (list) {
if (list.size() > 0) {//对于0，说明仓库中已经有1个元素了
try {
// 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到这里，说明仓库是空的，可以生产。
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒消费者进行消费
list.notify();
}
}
}
}
//消费线程
class Consumer implements Runnable {
// 仓库
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直消费
while (true) synchronized (list) {
if (list.size() == 0) {//等于0，说明仓库已经空了
try {
// 消费者线程等待，释放掉list集合的锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到此处说明仓库中有数据，进行消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒生产者生产
list.notify();
}
}
}
原文：https://www.cnblogs.com/yxc-160206/p/13282426.html