java学习笔记之多线程目录
java学习笔记之多线程
一、基本概念
首先来了解一下程序、进程和线程的概念及并行与并发
1.程序(program)
是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
2.进程(process)
是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程——生命周期
进程可以细化为多个线程。
3.线程(thread)
进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 每个线程拥有自己独立的：栈、程序计数器（PC）
- 多个线程，共享同一个进程中的结构：方法区、堆。
4.并行与并发
- 并行：多个CPU同时执行多个任务。比如：多人同时做不同的事。
- 并发：一个CPU（采用时间片）同时执行多个任务。比如：多个人做同一件事。
二、线程的创建和使用
方式一：继承于Thread类
1.继承于Thread类的线程创建方法
- 创建一个继承于Thread类的子类
- 重写run()方法，将此线程执行的操作声明在run()方法中
- 创建Thread类的子类的对象
- 通过对象调用start()方法
例：遍历100以内的所有偶数：
//1.创建一个继承于Thread的子类
class MyThread extends Thread{
//2.重写run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadCreate {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()
t1.start();
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println("main：" + i);
}
}
}
}
注意：1. 不能通过直接调用run()方法的方式启动线程；
2.如需再启动一个线程，不可以还让已经start()的线程去执行，会报"IllegalThreadStateException"错误，需要重新创建一个线程对象
练习：调用两个线程，分别遍历100以内的奇数和偶数
public class ThreadCreate {
public static void main(String[] args) {
//创建Thread类的匿名子类的方式比较简便
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println("偶数：" + i);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0){
System.out.println("奇数：" + i);
}
}
}
}.start();
}
}
2.Thread类常用方法
- start()：启动当前线程；调用当前线程的run()方法
- run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
- currentThread()：静态方法，返回执行当前代码的线程
- getName()：获取当前线程的名字
- setName()：设置当前线程的名字
- yield()：释放当前CPU的执行权
- join()：在线程a中调用线程b的join()，此时线程a进入阻塞状态，知道线程b完全执行完以后，线程a才结束阻塞状态
- stop()：已过时。当执行此方法时，强制结束当前进程。（这种方法本质上是不安全的）
- sleep(long millis)：让当前线程“睡眠”指定的毫秒数。在指定的毫秒时间内，当前线程处于阻塞状态
- isAlive()：判断当前线程是否存活
3.线程的调度
- java的调度方法：
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略
- 线程的优先级等级(常量)
- MAX_PRIORITY：10
- MIN_PRIORITY：1
- NORM_PRIORITY：5 (默认优先级)
- 涉及的方法
- getPriority()：返回线程优先值
- setPriority(int newPriority)：改变线程的优先级
说明：
- 线程创建时继承父线程的优先级 - 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
方式二：实现Runnable接口
1.实现Runnable接口方式创建线程
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()
//1.创建一个实现了Runnable接口的类
class MyThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadCreateTest2 {
public static void main(String[] args) {
//3.创建实现类的对象
MyThread myThread = new MyThread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(myThread);
//5.通过Thread类的对象调用start():(1)启动线程(2)调用当前线程的run()
t1.start();
}
}
例2：创建三个窗口卖票，总票数为100张，使用Runnable接口方式
//1.创建一个实现了Runnable接口的类
class Windows implements Runnable{
private int ticket = 100;
//2.实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
while (ticket > 0){
ticket--;
System.out.println(Thread.currentThread().getName() +"卖票成功，余票：" + ticket + "张");
}
}
}
public class Ticket {
public static void main(String[] args) {
//3.创建实现类的对象
Windows w = new Windows();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
//5.通过Thread类的对象调用start():(1)启动线程(2)调用当前线程的run()
t1.start();
t2.start();
t3.start();
}
}
注意：
- 上例存在线程安全问题，后边会解决
- 如果采用继承Thread类的方式创建线程，会创建三个Thread类的对象，每个对象中都会有票数ticket，相当于三个窗口各卖100张票；如果票数ticket使用static修饰，就是多个对象共用该变量了，比较麻烦。
- 采用Runnable接口方式实现，只创建了一个Windows类，所以，该类中的票数ticket为三个Thread类的对象共享的，不需要static修饰
2.创建线程的两种方式的比较
- 开发中优先选择：实现Runnable接口的方式
原因：
- 实现的方式没有类的单继承性的局限性；
- 实现的方式更适合来处理多个线程共享数据的情况。
-
联系：Thread类也实现了Runnable接口（可以参考源码）
-
相同点：两种方式都要重写run()，将线程要执行的逻辑声明在run()中。
方式三：实现Callable接口（JDK5.0新增）
1. 与使用Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTest类，比如获取返回结果
2. 实现Callable接口方法创建线程
- 创建一个实现Callable接口的实现类
- 实现call方法，将此线程需要执行的操作声明在call()方法中
- 创建Callable接口实现类的对象
- 将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
- 获取Callable中的call()方法的返回值。
例：创建一个线程，打印1-100以内的偶数，并输出所有偶数的和
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建线程分方式三：实现Callable接口。JDK5.0新增
*/
//1.创建一个实现Callable接口的实现类
class NumThread implements Callable<Integer>{
//2.实现call方法，将此线程需要执行的操作声明在call()方法中
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
Thread t1 = new Thread(futureTask);
t1.start();
try {
//6.获取Callable中的call()方法的返回值。
//get()方法返回值即为FutureTask构造器参数Callable实现类重写的call()方法的返回值。
Integer sum = futureTask.get();
System.out.println("100以内偶数的和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- call()方法可以有返回值；
- call()方法可以抛出异常，被外面的操作捕获，获取异常信息；
- Callable支持泛型
方式四、使用线程池（JDK5.0新增）
1. 线程池概述
- 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
- 好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- KeepAliveTime：线程没有任务时最多保持多长时间后会终止
- …
2. 使用线程池创建线程
- 提供制定线程数量的线程池
- 执行指定的线程操作。需要提供实现Runnable接口或Callable接口实现类的对象
- 关闭连接池
例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 线程创建方式四：使用线程池
*/
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);
}
}
}
}
public class ThreadNew2 {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; // 向下转型，以使用子类特有的方法
//设置线程池属性
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();....
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适用于Runnable
service.execute(new NumberThread());//适用于Runnable
// service.submit();//适用于Callable
//3.关闭连接池
service.shutdown();
}
}
3. java中的四种线程池
-
缓存线程池（长度无限制）
执行流程：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在则创建线程，并放入线程池，然后使用
//缓存线程池 ExecutorService service = Executors.newCachedThreadPool(); //向线程池中加入新的任务 service.execute(new Runnable() { @Override public void run() { System.out.println("线程名：" + Thread.currentThread().getName()); } }); -
定长线程池（长度是制定的数值）
执行流程：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
定长线程池 ExecutorService service = Executors.newFixedThreadPool(10); service.execute(new Runnable() { @Override public void run() { System.out.println("线程名：" + Thread.currentThread().getName()); } }); -
单线程线程池
效果与定长线程池创建时传入数值1效果一致
执行流程：
- 判断线程池的那个线程是否空闲
- 空闲则使用
- 不空闲则等待池中的单个线程空闲后使用
//单线程线程池 ExecutorService service = Executors.newSingleThreadExecutor(); service.execute(new Runnable() { @Override public void run() { System.out.println("线程名：" + Thread.currentThread().getName()); } }); -
周期性任务定长线程池
执行流程：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池然后使用
- 不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程后使用
周期性任务执行时：
定时执行，当某个时机触发时，自动执行某任务
//周期性任务定长线程池
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行：
* 参数1：Runnable类型的任务
* 参数2：时长数字
* 参数3：时长数字的单位
*/
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("线程名：" + Thread.currentThread().getName() + "的线程执行了");
}
},5,TimeUnit.SECONDS);
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("线程名：" + Thread.currentThread().getName() + "的线程执行了");
}
},5,2,TimeUnit.SECONDS);
线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。
- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开；
- 守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程；
- Java垃圾回收就是一个典型的守护线程；
- 若JVM中都是守护线程，当前JVM将退出。
三、线程的生命周期
JDK中用Thread.State类定义了线程的几种状态
- 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态；
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源；
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能；
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU并临时中止自己的执行，进入阻塞状态；
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
四、线程同步
1.概述
- 多个线程执行的不确定性引起执行结果的不稳定；
- 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
分析上边三个窗口卖票的例子：
-
问题：卖票过程中，出现了重票、错票 --> 出现了线程安全问题
问题出现的原因：当某个线程操作车票的过程中，尚未完成操作时，其他线程参与进来，也来操作车票。 -
解决措施：当一个线程在操作车票的时候，其他线程不能参与进来，直到该线程操作完，其他线程才可以开始操作车票，这种情况，及时该线程出现了阻塞，也不能改变。
在java中，通过同步机制，来解决线程的安全问题。 同步的好处和局限性： 好处：同步的方式，解决了线程的安全问题。 局限性：操作同步代码是，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。
方式一、同步代码块
结构：
synchronized(同步监视器){
//需要被同步的代码
}
需要被同步的代码，注意不能包含多，也不能包含少。比如把while(true)循环包含到同步代码块中，会造成只有一个窗口在卖票。
说明：
-
操作共享数据的代码，即为需要被同步的代码；
-
共享数据：多个线程共同操作的变量，比如例子中的车票ticket就是共享数据；
-
同步监视器，俗称：锁。任何一个类的对象都可用来充当锁。
要求：多个线程必须要共用一把锁。
补充：
- 在实现Runnable接口创建多线程的方式中，可以考虑使用this关键字充当同步监视器；
- 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可以考虑使用当前对类充当同步监视器。
修改后的代码：
class Windows implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {
if (ticket > 0) {
ticket--;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票成功，余票：" + ticket + "张");
} else {
break;
}
}
}
}
}
public class Ticket {
public static void main(String[] args) {
Windows w = new Windows();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
在解决继承Thread类的方式中，锁对象要使用static修饰。
方式二、同步方法
把同步代码块方式中，需要把同步的代码抽取为方法，并在方法名前边加上synchronized关键字，注意抽取方法的内容也是不能多，不能少。
同步方法处理实现Runnable接口的线程安全问题：
class Windows implements Runnable {
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
show();
if (ticket <= 0){
break;
}
}
}
private synchronized void show() {
if (ticket > 0) {
ticket--;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票成功，余票：" + ticket + "张");
}
}
}
public class Ticket {
public static void main(String[] args) {
Windows w = new Windows();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
注意：同步方法处理继承Thread类的线程安全问题，要把同步方法设置为静态的。
关于同步方法的总结：
1. 同步方法仍然涉及到同步监视器，只是不需要显式的声明；
2. 非静态的同步方法，同步监视器是：this
3. 静态的同步方法，同步监视器是：当前类本身
方式三、Lock（显式锁）
- 从jdk5.0开始，java提供了更强大的线程同步机制—通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
class Windows implements Runnable {
private int ticket = 100;
//1.实例化lock对象
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
//2.调用锁定方法lock()
lock.lock();
if (ticket > 0) {
ticket--;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票成功，余票：" + ticket + "张");
}else{
break;
}
} finally {
//3.调用解锁方法unloc()
lock.unlock();
}
}
}
}
public class Ticket {
public static void main(String[] args) {
Windows w = new Windows();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
死锁问题
- 死锁理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程死锁。
- 说明：
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续；
- 使用同步时要避免出现死锁。
- 解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
五、线程通信
例：使用两个线程交替打印1-100
/**
* 两个线程交替打印1-100之间的自然数
*/
class Number implements Runnable{
private int number = 1;
ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
synchronized (this) {
notify();
if (number <= 100){
System.out.println(Thread.currentThread().getName() + ":" +number);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
number++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number n = new Number();
Thread t1 = new Thread(n);
Thread t2 = new Thread(n);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
用到的三个方法：
-
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器；
-
notify():一旦执行此方法，就会唤醒被wait()阻塞的一个线程，如果有多个线程被阻塞，就唤醒优先级最高的那个进程。
-
notifyAll():一旦执行此方法，就会唤醒所有被wait()阻塞的线程
说明：
- 这三个方法必须使用在同步代码块或同步方法中。
- 这三个方法调用者必须是同步代码块或同步方法中的同步监视器。否则会出现IllegalMonitorStateException异常
- 这三个方法是定义在java.lang.Object类中的，方便任何对象调用。
经典例题：生产者/消费者问题
- 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
分析：
1. 是否多线程问题？是，生产者线程，消费者线程
2. 是否有数据共享？是，店员（或产品）
3. 如何解决线程的安全问题？同步机制
4. 是否涉及线程的通信？是
/**
* 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有
* 固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品
* 了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
*/
class Clerk{//店员
private int productNumber = 0;//产品数量
//同步监视器是当前对象this，只创建了一个clerk对象，所以两个方法用的是同一个同步监视器
public synchronized void produceProduct() {//生产产品
if (productNumber < 20){
productNumber++;
notify();//每生产一个产品就欢迎消费者一次
System.out.println(Thread.currentThread().getName() + "正在生产第" + productNumber + "个产品");
}else{
try {
wait();//产品数量为20，等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void consumeProduct() {//消费产品
if (productNumber > 0){
System.out.println(Thread.currentThread().getName() + "正在消费第" + productNumber + "个产品");
productNumber--;
notify();//每消费一个产品就唤醒生产者
}else{
try {
wait();//产品数量为0，等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Productor implements Runnable{//生产者线程
private Clerk clerk;//店员对象
public Productor(Clerk clerk){//以店员对象做构造方法的参数，来保证共用同一个店员对象
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始生产产品...");
while (true){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Customer implements Runnable{
private Clerk clerk ;
public Customer(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始消费产品...");
while (true){
try {
Thread.sleep(150);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();//实例化店员对象
Productor p = new Productor(clerk);//创建实现类生产者的对象
Customer c = new Customer(clerk);//创建实现类消费者的对象
Thread t1 = new Thread(p);//将生产者对象作为参数传递到Thread类的构造器中，创建Thread类的对象，生产者线程
Thread t2 = new Thread(p);//消费者线程1
Thread t3 = new Thread(c);//消费者线程2
t1.setName("生产者1");
t2.setName("消费者1");
t3.setName("消费者2");
t1.start();
t2.start();
t3.start();
}
}
ut.println(Thread.currentThread().getName() + "开始消费产品...");
while (true){
try {
Thread.sleep(150);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();//实例化店员对象
Productor p = new Productor(clerk);//创建实现类生产者的对象
Customer c = new Customer(clerk);//创建实现类消费者的对象
Thread t1 = new Thread(p);//将生产者对象作为参数传递到Thread类的构造器中，创建Thread类的对象，生产者线程
Thread t2 = new Thread(p);//消费者线程1
Thread t3 = new Thread(c);//消费者线程2
t1.setName("生产者1");
t2.setName("消费者1");
t3.setName("消费者2");
t1.start();
t2.start();
t3.start();
}
}
扫一扫
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
