多线程
- 线程概述
- 线程的创建
- 1. 继承Thread类
- 2. 实现Runnable接口
- 3. 实现Callable接口
- 4. 使用线程池
- 线程的调度
- 线程的生命周期
- 线程同步
- 1. 方法一：同步代码块
- 2. 方法二：同步方法
- 3. 方法三：Lock(锁)：
- 4. 对比三种方法
- 5. 典型例题
- 6. 线程死锁问题
- 线程通信
- 两个方法
- sleep()方法和wait()
- 典型例题
线程概述
问题引入：
单线程的程序往往功能十分有限，例如：开发一个服务器程序，这个服务器程序需要向不同的客户端提供服务，不同的客户之间应该互不干扰，否则这个程序将不会被接收。 单线程程序只有一个顺序执行流，多线程则可以包括多个顺序执行流，多个线程之间互不干扰。
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 如：运行中的QQ，运行中的MP3播放器
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程（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新增的创建线程的方式。
- 步骤：
1. 创建一个实现callable的实现类。
2. 实现call方法，将此线程需要执行的操作声明在call方法中。类似与前面的run方法。
3. 创建Callable接口实现类的对象
4. 将此Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象。
5. 将FutureTask类的序传递到Thread类的构造器中，创建Thread类的对象，通过该对象启动线程
6. 可以获取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类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
线程同步
问题引入：
实现三个窗口，卖票的程序：
继承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 --> 同步代码块（已经进入了方法体，分配了相应资源）–> 同步方法（在方法体之外）
总结：
解决线程安全问题，有几种方式？
- synchronized
- 同步代码块
- 同步方法
- Lock
5. 典型例题
线程安全问题的例题：
银行有一个账户。有两个储户分别向同一个账户存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(pronum<20){
pronum++;
System.out.println(Thread.currentThread().getName()+":开始生产第"+pronum+"个产品");
notify();
}
else{
//等待
try
{
wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct()
{
if(pronum>0)
{
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();
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
