讲给女朋友听的java多线程（2万字深入理解多线程，有实例代码辅助理解）
多线程线程概述线程的创建1. 继承Thread类2. 实现Runnable接口3. 实现Callable接口4. 使用线程池线程的调度线程的生命周期线程同步1. 方法一：同步代码块2. 方法二：同步方法3. 方法三：Lock(锁)：4. 对比三种方法5. 典型例题6. 线程死锁问题线程通信两个方法sleep()方法和wait()典型例题
肯定是，两个线程，分别是两个储户 是否有共享数据？
有，账户 所以，存在线程安全问题。 使用同步机制解决
1. 两个方法声明的方法不一样，Thread类中声明sleep()，Object类中声明wait()。
2. 调用的范围不一样。sleep()方法可以在任意需要的位置调用。wait()方法必须使用在同步代码块或同步方法中。
3. 如果两个方法都使用在他代码块或同步方法中：sleep()方法不会释放锁，wait()方法会释放锁 典型例题
读完本文大概需要30分钟左右，本文有大量的实例代码和典型例题帮助大家理解java多线程。虽然多线程比较难以理解，仅靠一篇文章恐怕搞不定。但读完本文最起码能让你搞懂java多线程的70%以上，至于熟练运用，还是得大量的练习为基础。
码字不易，望三连~~~
问题引入：
单线程的程序往往功能十分有限，例如：开发一个服务器程序，这个服务器程序需要向不同的客户端提供服务，不同的客户之间应该互不干扰，否则这个程序将不会被接收。 单线程程序只有一个顺序执行流，多线程则可以包括多个顺序执行流，多个线程之间互不干扰。
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。（4种方式创建多线程）
若一个进程同一时间并行执行多个线程，就是支持多线程的 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 一个进程中的多个线程共享相同的内存单元/内存地址空间–>它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患单核CPU：是一种假的多线程，因为频率很高，所以我们感觉不到。
一个java程序，其实至少有三个进程：
① main()方法主进程。
② gc()垃圾回收线程。
③ 异常处理线程，异常会影响主线程。
并发与并行：
并发：多个CPU同时执行多个任务。比如：多个人同时做不同的事 并行：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事 多线程程序的优点： 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 提高计算机系统CPU的利用率 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改 何时需要多线程： 程序需要同时执行两个或多个任务。 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。 需要一些后台运行的程序时 线程的创建 1. 继承Thread类（1）多线程的创建：方法一：继承Thread类
步骤：
创建一个继承于Thread类的子类 重写Thread类的run方法–>将此线程执行的操作声明在run()中。 创建子类对象 通过子类对象调用start()方法：注意：
①启动线程。
②start方法会自动调用当前线程的run方法。不能直接调用run方法。
③不能让已经start的线程再去执行，会报异常。需要再去创建一个线程对象，通过这个对象再start。
class Test extends Thread{
@Override
public void run()
{
for(int i=0;i<100;i++)
{
if(i%2==0)
{
System.out.println("偶数："+i);
}
}
}
}
public class Demo1 {
public static void main(String[] args)
{
Test test = new Test();
test.start();
Thread.currentThread().setName("主线程");//给main程序命名
//创建Thread类的匿名子类
new Thread()
{
@Override
public void run()
{
for(int i=0;i<100;i++)
{
if(i%2!=0)
{
System.out.println(Thread.currentThread().getName()+"匿名奇数："+i);
}
}
}
}.start();
}
}
Thread类的有关方法：
void start();: 启动线程，并执行对象的run()方法
run();: 需要被重写，线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。
static void yield()：线程让步，释放CPU使用权，有可能在释放之后有被分配到使用权。
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：在当线程a中的调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完毕，线程才结束阻塞，继续执行。比如：线程a的运行过程中需要一个参数，这个参数需要线程b提供，这时，就需要join()方法。
static void sleep(long millis)：(指定时间:毫秒)让当前线程睡眠
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常。使用try-catch语句处理异常
stop(): 强制线程生命期结束，不推荐使用。（已经过时了）boolean isAlive()：返回boolean，判断线程是否还活着
2. 实现Runnable接口
（2）多线程的创建：方法二：实现Runnable接口
步骤： 创建一个实现了Runnable接口的类 实现Runnable接口中的方法 创建实现类的对象 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 通过Thread类的对象调用start()方法class Test3 implements Runnable{
@Override
public void run()
{
for(int i=0;i<100;i++)
{
if(i%2==0)
{
System.out.println("偶数："+i);
}
}
}
}
public class Demo1 {
public static void main(String[] args)
{
Test3 test3 = new Test3();
Thread t = new Thread(test3);
t.start();
}
}
两个创建线程的比较：
实现Runnable的方式更好一点。因为实现它的类可能还有其他的直接父类，导致不能继承Thread，java是单继承的，但是可以同时有继承和实现。实现的方式会默认共享数据。
所以，在开发中，优先使用实现Runnable的方式。
实现的方式没有类单继承的局限性 实现的方式更适合来处理多个线程共享数据的情况。 相同点：都需要重写run方法。继承的方式在内部也实现的Runable接口。 3. 实现Callable接口（3）多线程的创建：方法三：实现Callable接口
此方法为JDK5.0新增的创建线程的方式。
步骤：
创建一个实现callable的实现类。 实现call方法，将此线程需要执行的操作声明在call方法中。类似与前面的run方法。 创建Callable接口实现类的对象 将此Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象。 将FutureTask类的序传递到Thread类的构造器中，创建Thread类的对象，通过该对象启动线程 可以获取Callable实现类的call方法的返回值。（可选，需要返回值就get，不需要就吧get）特点：
与使用Runnable相比， Callable功能更强大些 相比run()方法，可以有返回值 方法可以抛出异常 支持泛型的返回值 需要借助FutureTask类，比如获取返回结果如何理解实现Callable接口创建多线程比实现Runnable接口创建多线程的方式给强大？
call()方法可以有返回值。 call()方法可以抛出异常，被外面的操作捕获，然后处理异常 call()方法支持泛型
class NewThread implements Callable{
@Override
public Object call() throws Exception
{
int sum=0;
for(int i=1;i<=100;i++)
{
if(i%2==0)
{
sum=sum+i;
}
}
return sum;//自动装箱
}
}
public class ThreadNew {
public static void main(String[] args)
{
NewThread newThread = new NewThread();
FutureTask futureTask = new FutureTask(newThread);
Thread t1 = new Thread(futureTask);
t1.start();
try
{
//get方法的返回值即为FutureTask构造器参数Callable实现类对象重写的call方法的返回值。
//get方法只是为了返回call方法的返回值。
Object sum = futureTask.get();//get方法自动调用newThread类对象的call()方法
System.out.println(sum);
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
}
4. 使用线程池
（3）多线程的创建：方法四：使用线程池
背景：
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
类似生活中的公共交通工具。
好处：
提高响应速度（减少了创建新线程的时间） 降低资源消耗（重复利用线程池中线程，不需要每次都创建） 便于线程管理 corePoolSize：核心池的大小 maximumPoolSize：最大线程数 keepAliveTime：线程没有任务时最多保持多长时间后会终止 步骤： 提供指定实数量的线程池 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口的实现类对象 关闭线程池
class NewThread5 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 NewThread6 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 NewThread4 {
public static void main(String[] args)
{
//service是线程池
ExecutorService service = Executors.newFixedThreadPool(10);
NewThread5 newThread5 = new NewThread5();
NewThread6 newThread6 = new NewThread6();
//输出偶数的线程
service.execute(newThread5);//适合于Runable
//输出奇数的线程
service.execute(newThread6);//适合于Runable
// service.submit()//适合Callab
service.shutdown();//关闭线程池
}
}
线程的调度
（1）Java的调度方法
同优先级线程组成先进先出队列（先到先服务），使用时间片策略 对高优先级，使用优先调度的抢占式策略（2）线程的优先级
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5
（3）方法：
getPriority() ：返回线程优先值
setPriority(int p) ：改变线程的优先级。
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);//设置为最大优先级``
（4）说明：
高优先级的程序要抢占低优先级CPU的执行权，但只是从概率上讲，高有优先级的程序高概率被执行。并不意味着只有当高优先级执行完之后才执行低优先级。
生命周期：
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
问题引入：
实现三个窗口，卖票的程序：
继承Thread方式创建多线程：
class Window extends Thread{
private int ticket=100;//会有三百张票，可以使用static解决，暂时有问题，会出现买三张100
@Override
public void run()
{
while (true)
{
if(ticket>0)
{
System.out.println(Thread.currentThread().getName()+":"+"卖票，票号为："+ticket);
ticket--;
}
else {
break;
}
}
}
}
public class Demo2 {
public static void main(String[] args)
{
Window w1 = new Window();//new了三个Windowd对象
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
实现Runnable接口方式创建多线程
//但是也存在线程安全问题，有三个100的票
class Window2 implements Runnable{
private int ticket=100;//不用static也可以三个线程共用一个ticket
@Override
public void run()
{
while (true)
{
if(ticket>0)
{
System.out.println(Thread.currentThread().getName()+":"+"卖票，票号为："+ticket);
ticket--;
}
else {
break;
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args)
{
Window2 w1 = new Window2();//因为只new了一个Window对象，所有共用一个ticket
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
问题：
上面的代码存在线程安全问题，例如：会出现三个票号100的票、重票、错票的问题。
出现问题的原因：
当某个线程操作车票的过程中，尚未完成操作，其线程也参与进来操作车票
解决：
当一个线程A在操作车票时，其他线程不能参与进来，当A操作完成后，其他线程再操作。即使线程A出现阻塞，也不能改变。
在java中通过同步机制解决。
1. 方法一：同步代码块格式：
Object obj = new Object()
synchronized(obj){
//需要被同步的代码，即：操作共享数据的代码
}
共享数据：多个线程共同操作的变量，本例中的ticket
同步监视器：俗称“锁”。
锁的要求：
任何一个类的对象都可以充当一个锁。 多个线程共用同一个锁。注意：
必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
补充：
在实现Runnable接口创建多线程的方式中，我们可以使用this充当所，代替手动new一个对象，因为后面我们只创建一个线程的对象。 在继承Thread类创建多线程的方式中，慎用this，考虑我们的this是不是唯一的。我们可以使用当前类来充当这个是锁。synchronized (Window.class)
同步的优缺点：
好处：解决了线程安全问题 缺点；操作同步代码时，只能有一个线程参与，其他线程等待，相当于单线程。同步的范围：
（1）如何找问题，即代码是否存在线程安全？（非常重要）
明确哪些代码是多线程运行的代码 明确多个线程是否有共享数据 明确多线程运行代码中是否有多条语句操作共享数据（2）如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中
（3）切记：
实现Runnable接口创建多线程使用同步代码块解决问题的代码：
class Window2 implements Runnable{
private int ticket=100;//不用static也可以三个线程共用一个ticket
// Object obj = new Object();//这个锁只能放在run之外，保证每个线程共用同一个锁
//使用this代替什么的obj
@Override
public void run()
{
while (true)
{
synchronized(this)
{
if (ticket > 0)
{
try
{
Thread.sleep(100);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + "卖票，票号为：" + ticket);
ticket--;
} else
{
break;
}
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args)
{
Window2 w1 = new Window2();//因为只new了一个Window对象，所有共用一个ticket
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
继承Thread类创建多线程使用同步代码块解决问题的代码：
class Window extends Thread{
private static int ticket=100;//使用static保证 共用ticket
// private static Object obj = new Object();//因为后面创建了三个对象，所以需要static来保证是同一把锁
//不能使用this，因为后面会有三个Window对象。
//可以使用Window.class，类也是一个对象，是唯一的
@Override
public void run()
{
while (true)
{
synchronized (Window.class)
{
if (ticket > 0)
{
try
{
sleep(100);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + "卖票，票号为：" + ticket);
ticket--;
} else
{
break;
}
}
}
}
}
public class Demo2 {
public static void main(String[] args)
{
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
2. 方法二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们可以将这个方法声明为同步的。
同步方法仍然有同步监视器，只是不需要我们显示的声明。
非静态同步方法，同步监视器：this 静态同步方法，同步监视器：当前类本身单例模式之懒汉式的线程安全问题解决：
/*方式一：效率过差：
因为只创建一个对象，当有一个线程已经创建了之后，其他线程还在等，也会进入去判断一下。
*/
class Bank{
private Bank()
{}
private static Bank instance=null;
//同步方法
public static synchronized Bank getInstance()
{
if(instance==null)
{
instance = new Bank();
}
return instance;
}
}
/*方式二：效率较高：
有对象之后，其他线程就不用再进入同步代码块
*/
class Bank2{
private Bank2()
{}
private static Bank2 instance=null;
public static Bank2 getInstance()//同步监视器：类本期
{
//效率比较高，有对象之后，其他线程就不用再进入同步代码块
if(instance==null)
{
synchronized (Bank2.class)
{
if (instance == null)
{
instance = new Bank2();
}
}
}
return instance;
}
}
3. 方法三：Lock(锁)：
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
/**
* synchronized 和lock有何不同？
*
* 1.synchronized是自动释放锁
* 2.lock需要手动的启动同步，结束同步也需要手动释放锁
*
* 解决线程安全问题的方法三：Lock锁
* @author shkstart
* @create 2020-04-07-18:21$
*/
class Window5 implements Runnable{
private int ticket = 100;
//1. 实力化一个ReentrantLock对象
private ReentrantLock lock = new ReentrantLock();//默认参数是false，写为true之后，表示是公平的锁
@Override
public void run()
{
while (true)
{
try
{
//2. 调用锁定方法。lock方法。获得锁
lock.lock();
if(ticket>0)
{
try
{
Thread.sleep(100);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + "卖票，票号为：" + ticket);
ticket--;
}
else
{
break;
}
}finally
{
//3. 解锁
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args)
{
Window5 w5 = new Window5();
Thread t1 = new Thread(w5);
Thread t2 = new Thread(w5);
Thread t3 = new Thread(w5);
t1.setName("窗口一：");
t2.setName("窗口二：");
t3.setName("窗口三：");
t1.start();
t2.start();
t3.start();
}
}
4. 对比三种方法
synchronized 与 Lock 的对比：
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放 Lock只有代码块锁，synchronized有代码块锁和方法锁 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）优先使用顺序：
Lock --> 同步代码块（已经进入了方法体，分配了相应资源）–> 同步方法（在方法体之外）
总结：
解决线程安全问题，有几种方式？
线程安全问题的例题：
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
问题分析：
是不是多线程问题？肯定是，两个线程，分别是两个储户 是否有共享数据？
有，账户 所以，存在线程安全问题。 使用同步机制解决
/**
*
* @author shkstart
* @create 2020-04-07-18:48$
*/
class Account{
private double balance;
private static ReentrantLock lock = new ReentrantLock();//使用继承的方式创建多线程，需要加static，保证是一把锁
public Account(double balance)
{
this.balance=balance;
}
// public synchronized void deposit(double amt)方法一：使用synchronized的同步方法
//方法二：使用lock
public void deposit(double amt)
{
try
{
lock.lock();
if(amt>0)
{
try
{
Thread.sleep(1000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
balance=balance+amt;
System.out.println(Thread.currentThread().getName()+":"+"存钱成功，余额为："+balance);
}
}
finally
{
lock.unlock();
}
}
}
class Customer extends Thread{
private Account account;
public Customer(Account account)
{
this.account=account;
}
@Override
public void run()
{
for(int i=0;i<3;i++)
{
account.deposit(1000);
}
}
}
public class Test1 {
public static void main(String[] args)
{
Account account = new Account(0);
Customer customer1 = new Customer(account);
Customer customer2 = new Customer(account);
customer1.setName("甲");
customer2.setName("乙");
customer1.start();
customer2.start();
}
}
注意：推荐使用实现的方式创建多线程。采用继承时，使用同步方法时，慎用this，这个题可以使用this，是因为this是唯一的，是同一个Account。
6. 线程死锁问题不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续类似与死循环。
如下代码就出现了线程死锁问题：
public class Lock {
public static void main(String[] args)
{
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
//继承方式创建匿名多线程
new Thread()
{
@Override
public void run()
{
synchronized (s1)
{
s1.append("A");
s2.append("1");
try
{
Thread.sleep(100);//加大死锁概率
} catch (InterruptedException e)
{
e.printStackTrace();
}
synchronized (s2)
{
s1.append("B");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
//实现方式创建匿名多线程
new Thread(new Runnable() {
@Override
public void run()
{
synchronized (s2)
{
s1.append("C");
s2.append("3");
synchronized (s1)
{
s1.append("D");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
解决方法：
专门的算法、原则 尽量减少同步资源的定义 尽量避免嵌套同步 线程通信 两个方法两个常用方法：wait(); 和 notify();
wait();是调用其的线程进入阻塞状态。并释放锁。 notify();唤醒被阻塞的线程。如果有多个线程，就唤醒优先级高的那个。 notifyAll();唤醒所有被阻塞的线程。注意：
上面三个方法只能出现在同步方法或同步代码块中。不能在lock中。 这三个方法是定义在Object类中。 这三个方法的调用者必须是同步方法或同步代码块的同步监视器（锁），否则，会出现非法监视器的错误。如下这种会报错。java.lang.IllegalMonitorStateException：非法监视器错误。
class Number implements Runnable{
private int number=1;
private ReentrantLock lock = new ReentrantLock();
Object object = new Object();
@Override
public void run()
{
while (true)
{
synchronized (object)
{
notify();//唤醒一个线程，默认是this调用。
if(number<101)
{
System.out.println(Thread.currentThread().getName()+"打印："+number);
number++;
try
{
wait();//使得调用如下wait方法的线程进入阻塞状态，wait会是否锁
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
else
{
break;
}
}
}
}
}
sleep()方法和wait()
sleep()方法和wait()方法的异同：
相同点：都可以让当前线程进入阻塞状态。 不同点：1. 两个方法声明的方法不一样，Thread类中声明sleep()，Object类中声明wait()。
2. 调用的范围不一样。sleep()方法可以在任意需要的位置调用。wait()方法必须使用在同步代码块或同步方法中。
3. 如果两个方法都使用在他代码块或同步方法中：sleep()方法不会释放锁，wait()方法会释放锁 典型例题
生产者和消费者的问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：
生产者比消费者快时，消费者会漏掉一些数据没有取到。 消费者比生产者快时，消费者会取相同的数据。问题分析：
是否是多线程？是，生产者线程，消费者线 共享数据：店员（产品） 解决线程安全问题？同步机制，三种方法 线程的通信
/**
*
* @author shkstart
* @create 2020-04-07-21:11$
*/
class Clerk{//店员
private int pronum=0;
//生产产品
public synchronized void producePorduct()//同步方法
{
if(pronum0)
{
System.out.println(Thread.currentThread().getName()+"：开始消费第"+pronum+"个产品");
pronum--;
notify();
}
else
{
//等待
try
{
wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
//生产者线程
class Producer implements Runnable{
private Clerk clerk;
public Producer(Clerk clerk)
{
this.clerk=clerk;
}
@Override
public void run()
{
System.out.println(Thread.currentThread().getName()+"开始生产……");
while (true)
{
try
{
Thread.sleep(100);
} catch (InterruptedException e)
{
e.printStackTrace();
}
clerk.producePorduct();//生产者生产产品
}
}
}
//消费者线程
class Consumer implements Runnable{
private Clerk clerk;
public Consumer(Clerk clerk)
{
this.clerk=clerk;
}
@Override
public void run()
{
System.out.println(Thread.currentThread().getName()+"开始消费……");
while(true)
{
try
{
Thread.sleep(100);
} catch (InterruptedException e)
{
e.printStackTrace();
}
clerk.consumeProduct();//消费者消费产品
}
}
}
public class ProductTest {
public static void main(String[] args)
{
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Consumer c1 = new Consumer(clerk);
Thread t1 = new Thread(p1);
t1.setName("生产者");
Thread t2 = new Thread(c1);
t2.setName("消费者");
t1.start();
t2.start();
}
}
【传送门】
关注博主，持续变强。
