Erfahren Sie mehr über den Java-Multithreading-Mechanismus

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java und stellt hauptsächlich verwandte Themen zum Thema Multithreading vor, darunter Programme, Prozesse, Threads, drei Möglichkeiten zum Erstellen von Threads, den Status von Threads usw. Schauen wir uns das an Ich hoffe, dass der folgende Inhalt für alle hilfreich ist.

Empfohlenes Lernen: „Java-Video-Tutorial“

1. Programm, Prozess, Thread

1.1 Was ist ein Programm

Programm (Programm): Es ist in einer bestimmten Sprache geschrieben, um eine bestimmte Aufgabe zu erfüllen Aufgabe Eine Reihe von Anweisungen ist ein statisches Stück Code. (Das Programm ist statisch)

1.2 Was ist ein Prozess? Prozess (Prozess): Es ist ein Ausführungsprozess eines Programms, ein laufendes Programm. Der Prozess ist die Einheit der Ressourcenzuweisung, und das wird auch so sein Im Speicher werden für jeden Prozess unterschiedliche Speicherbereiche reserviert. (Der Prozess ist dynamisch) Es handelt sich um einen dynamischen Prozess: Es gibt einen eigenen Prozess der Erstellung, Existenz und des Todes

Derzeit unterstützt das Betriebssystem mehrere Prozesse und kann mehrere Prozesse gleichzeitig ausführen Gleichzeitig. Unterscheiden Sie nach der Prozess-ID

1.3 Was ist ein Thread? Thread (Thread): Ein Ausführungspfad in einem Prozess, der auch die grundlegende Planungseinheit von CUP ist , von denen jeder unterschiedliche Aufgaben erledigt, die von mehreren Threads gleichzeitig ausgeführt werden, wird als Multithreading bezeichnet.

Thread-Zusammensetzung

Die Grundkomponenten, die jeder Thread hat:
CPU-Zeitscheibe: Das Betriebssystem (OS) weist jedem Thread Ausführungszeit zu.

Laufende Daten: Heap-Speicherplatz (Speichern von Objekten, die Threads verwenden müssen; mehrere Threads können Objekte im Heap gemeinsam nutzen); Eigenschaften von Threads

• Präventive Thread-Ausführung (hohe Effizienz, kann verhindern, dass ein einzelner Thread die CPU für längere Zeit monopolisiert)
• Wenn eine Single-Core-CPU ausgeführt wird, erfolgt die Ausführung ausschließlich nach Zeitscheiben Ein Thread kann in einer Zeitscheibe ausgeführt werden, da die Zeitscheibe extrem kurz ist und wir das Gefühl haben, dass sie „gleichzeitig“ ablaufen.

Eine Multi-Core-CPU erreicht tatsächlich die gleichzeitige Ausführung mehrerer Threads in einem Zeitabschnitt.

In einer Single-Core-CPU ist makroskopisch die gleichzeitige Ausführung und mikroskopisch die sequentielle Ausführung möglich. 1.4 Der Unterschied zwischen Prozessen und Threads.

Ein Prozess ist die Grundeinheit der Ressourcenzuweisung im Betriebssystem, und Threads sind die Grundplanungseinheit der CPU.
• Nachdem ein Programm ausgeführt wurde, gibt es mindestens einen Prozess.
• Ein Prozess kann mehrere Threads enthalten, aber Es muss mindestens ein Thread vorhanden sein, sonst ist der Prozess bedeutungslos
• Die Datensegmentadresse kann nicht von Prozessen gemeinsam genutzt werden, sie kann jedoch von Threads desselben Prozesses gemeinsam genutzt werden.

2. Drei Möglichkeiten zum Erstellen von Threads

2.1 Erben Sie die Thread-Klasse und überschreiben Sie die run()-Methode

Spezifische Implementierung
• 1. Erben Sie die Thread-Klasse
2. Überschreiben Sie die run()-Methode
• 3. Erstellen Sie ein untergeordnetes Klassenobjekt
4. Rufen Sie die start()-Methode auf (
• PS: Rufen Sie nicht die run()-Methode auf, dies entspricht dem normalen Aufruf der Objektmethode und dem Starten des Threads
)

Geerbte Klasse

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i " + i);
        }
    }}

Testklasse

public class TestThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 1; i "+i);
        }
    }}

Ergebnis

Holen Sie sich die Thread-ID und den Namen

getId()//Holen Sie sich die ID des Threads, jeder Thread hat seine eigene ID

getName() //Den Threadnamen abrufen

Thread.currentThread()//Den aktuellen Thread abrufen

code

public class TestThread {

	public static void main(String[] args) {
		MyThread t=new MyThread();
		t.start();
        //只能在继承Thread类的情况下用
		System.out.println("线程id:"+t.getId());
		System.out.println("线程名字:"+t.getName());
        //调用Thread类的静态方法获取当前线程（这里获取的是主线程）
		System.out.println("线程id:"+Thread.currentThread().getId());
		System.out.println("线程名字:"+Thread.currentThread().getName());
	}}

Threadnamen ändern

Nur der Name des Threads kann geändert werden, aber die ID des Threads kann nicht geändert werden (id wird automatisch vom System zugewiesen)

1. Verwenden Sie die Konstruktormethode der Thread-Unterklasse, um den Wert zuzuweisengetId()//获取线程的id，每个线程都有自己的id
getName()//获取线程名字
Thread.currentThread()//获取当前线程

代码

public class MyThread extends Thread{
	public MyThread() {}//无参构造器
	public MyThread(String name) {
		super(name);
	}
	public void run() {
		for(int i=1;i<p><img src="https://img.php.cn/upload/article/000/000/067/57e2f75a769022a530da131db2d02e06-6.png" alt="Erfahren Sie mehr über den Java-Multithreading-Mechanismus"></p><h3>修改线程名称</h3><blockquote><p>只能修改线程的名称，不能修改线程的id（id是由系统自动分配）<br> 1、使用线程子类的构造方法赋值<br> 2、调用线程对象的<code>setName()</code> 2. Rufen Sie <code>setName() Methode des Thread-Objekts</code></p></blockquote><p><strong>Code</strong></p><pre class="brush:php;toolbar:false">public class MyThread extends Thread{
	public MyThread() {}//无参构造器
	public MyThread(String name) {
		super(name);
	}
	public void run() {
		for(int i=1;i<pre class="brush:php;toolbar:false">public class TestThread {

	public static void main(String[] args) {
		MyThread t1=new MyThread("子线程1");//通过构造方法
		MyThread t2=new MyThread();
		t2.setName("子线程2");
		System.out.println("线程t1的id："+t1.getId()+" 名称："+t1.getName());
		System.out.println("线程t2的id："+t2.getId()+" 名称："+t2.getName());
	}}

2.2 实现Runnable接口实现run()方法

具体实现

1.实现Runnable接口
2.实现run()方法
3.创建实现类对象
4.创建线程类对象
5.调用start()方法

实现接口

public class MyRunnable implements Runnable{//实现接口
	@Override
	public void run() {//实现run方法
		// TODO Auto-generated method stub
		for(int i=1;i<p><strong>测试类</strong></p><pre class="brush:php;toolbar:false">public class TestRunnable {
	public static void main(String[] args) {
		//1.创建MyRunnable对象，表示线程执行的功能
		Runnable runnable=new MyRunnable();
		//2.创建线程对象
		Thread th=new Thread(runnable);
		//3.启动线程
		th.start();
		for(int i=1;i<p><img src="https://img.php.cn/upload/article/000/000/067/beb0b9e2f551ceb35ac7ab846edfec3d-8.png" alt="Erfahren Sie mehr über den Java-Multithreading-Mechanismus"></p><h3>使用匿名内部类</h3><blockquote><p>如果一个线程方法我们只使用一次，那么就不必设置一个单独的类，就可以使用匿名内部类实现该功能</p></blockquote><pre class="brush:php;toolbar:false">public class TestRunnable {
	public static void main(String[] args) {
		Runnable runnable=new Runnable() {			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=1;i<h2>2.3 实现Callable接口</h2><h3>Callable和Thread、Runnable比较</h3><blockquote>
<p>对比继承<code>Thread</code>类和实现<code>Runnable</code>接口创建线程的方式发现，都需要有一个<code>run()</code>方法，但是这个run()方法有不足：</p>
<ul>
<li>没有返回值</li>
<li>不能抛出异常</li>
</ul>
<p>基于上面的两个不足，在JDK1.5以后出现了第三种创建线程的方式：实现<code>Callable</code>接口</p>
<p>实现<code>Callable</code>接口的好处：</p>
<ul>
<li>有返回值</li>
<li>能抛出异常</li>
</ul>
<p>缺点：</p>
<ul><li>创建线程比较麻烦</li></ul>
</blockquote><blockquote>
<p>1.实现<code>Callable</code>接口，可以不带泛型，如果不带泛型，那么call方法的返回值就是<code>Object</code>类型</p>
<p>2.如果带泛型，那么call的返回值就是泛型对应的类型</p>
<p>3.从call方法看到：方法有返回值，可以抛出异常</p>
</blockquote><h3>具体实现</h3><p><strong>实现接口</strong></p><pre class="brush:php;toolbar:false">import java.util.Random;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class TestCallable implements Callable<integer>{

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		return new Random().nextInt(10);
	}}</integer>

测试类

import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		TestCallable tc=new TestCallable();
		FutureTask<integer> ft=new FutureTask(tc);
		//创建线程对象
		Thread th=new Thread(ft);
		th.start();
		//获取线程得到的返回值
		Integer In=ft.get();
		System.out.println(In);
	}}</integer>

三、线程的状态

3.1 基本四状态

3.2 等待状态

3.3 阻塞状态

四、线程常用的方法

• 休眠（当前线程主动休眠millis毫秒）public static void sleep(long millis)

• 放弃（当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片）public static void yield()

• 加入（当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程）public final void join()//必须先start()，在join()，才有效

• 优先级（线程优先级为1–10，默认为5，优先级越高，表示获取CPU机会越多）线程对象.setPriority()

• 守护线程

  • 线程对象.setDaemon(true)；设置为守护线程
  • 线程有两类：用户线程（前台线程）、守护线程（后台线程）
  • 如果程序中所有前台线程都执行完毕了，后台线程也会自动结束
  • 垃圾回收器线程属于守护线程

4.1 线程休眠（sleep）

public static void sleep(long millis)当前线程主动休眠millis毫秒

子线程

public class SleepThread extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <p><mark>PS：sleep()的异常在run方法中是不能抛出的，只能用try–catch处理</mark><br><strong>测试类</strong></p><pre class="brush:php;toolbar:false">public class Test01 {
    public static void main(String[] args) {
        SleepThread sleepThread = new SleepThread();
        sleepThread.start();
    }}

结果：每次间隔100ms输出一次

4.2 线程放弃（yield）

public static void yield()当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

子线程

public class YieldThread extends Thread{
    @Override
    public void run() {
        for (int i=1;i<p><strong>测试类</strong></p><pre class="brush:php;toolbar:false">public class Test01 {
    public static void main(String[] args) {
        YieldThread yieldThread01 = new YieldThread();
        YieldThread yieldThread02 = new YieldThread();
        yieldThread01.start();
        yieldThread02.start();
    }}

结果：基本都会交替进行，也会有一个线程连输出

4.3 线程加入（join）

当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程，必须先start，再join才有效

子线程

public class JoinThread extends Thread{
    @Override
    public void run() {
        for (int i=1;i<p><strong>测试类</strong></p><pre class="brush:php;toolbar:false">public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        for (int i=1;i<p><strong>结果：当主线程打印到5的时候，这时候子线程加入进来，就先执行完子线程，在执行主线程</strong><br><img src="https://img.php.cn/upload/article/000/000/067/da3747d2bd3ee6a154b0a90e8cc9f0a7-14.png" alt="Erfahren Sie mehr über den Java-Multithreading-Mechanismus"></p><h2>4.4 守护线程（setDaemon）</h2><blockquote><p>将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了<br> 注意：<strong>先设置，在启动</strong></p></blockquote><p><strong>子线程</strong></p><pre class="brush:php;toolbar:false">public class TestThread extends Thread{
    @Override
    public void run() {
        for(int i=1;i<p><strong>测试类</strong></p><pre class="brush:php;toolbar:false">public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        TestThread daemonThread = new TestThread();
        daemonThread.setDaemon(true);//设置守护线程
        daemonThread.start();
        for (int i=1;i<p><strong>结果：当主线程结束时，子线程也跟着结束，并不会继续执行下去打印输出</strong><br><img src="https://img.php.cn/upload/article/000/000/067/da3747d2bd3ee6a154b0a90e8cc9f0a7-15.png" alt="Erfahren Sie mehr über den Java-Multithreading-Mechanismus"></p><h2>4.5 线程优先级（setPriority）</h2><blockquote><p>线程优先级为1-10，默认为5，优先级越高，表示获取CPU机会越多<br><img src="https://img.php.cn/upload/article/000/000/067/da3747d2bd3ee6a154b0a90e8cc9f0a7-16.png" alt="Erfahren Sie mehr über den Java-Multithreading-Mechanismus"></p></blockquote><p><strong>子线程</strong></p><pre class="brush:php;toolbar:false">public class TestThread extends Thread{
    @Override
    public void run() {
        for(int i=1;i<p><strong>测试</strong></p><pre class="brush:php;toolbar:false">public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        TestThread th1 = new TestThread();
        TestThread th2 = new TestThread();
        TestThread th3 = new TestThread();
        th1.setPriority(10);//设置线程1优先级10
        th1.start();
        th2.start();//线程2优先级默认不变，为5
        th3.setPriority(1);//设置线程3优先级为1
        th3.start();
    }}

结果：优先级（th1>th2>th3）线程3应该在最后打印

五、线程安全问题

5.1 卖票案例

需求：模拟三个窗口，每个窗口有100个人，同时抢10张票

使用继承Runnable接口的方法

public class BuyTicketRunnable implements Runnable{
	
	private int ticketNum=10;
	@Override
	public void run() {
		for(int i=1;i<p><strong>测试方法</strong></p><pre class="brush:php;toolbar:false">public class BuyTicketTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Runnable runnable=new BuyTicketRunnable();
		
		Thread th1=new Thread(runnable,"窗口1");
		Thread th2=new Thread(runnable,"窗口2");
		Thread th3=new Thread(runnable,"窗口3");
		
		th1.start();
		th2.start();
		th3.start();
	}}

结果

我们发现，不同窗口会抢到同一张票！！！，这在实际情况是不允许的，这是因为多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。（但窗口2抢到第10张票，还没来得及ticketNum--操作，时间片就用完了，随后被窗口三抢到CPU资源，此时的票数还是10，窗口三也抢到第十张票，也还没来得及ticketNum--操作窗口三时间片由完了，窗口一抢到CPU资源，还是买到了第10张票）

多线程安全问题：

• 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致
• 临界资源：共享资源（同一对象），一次只能允许一个线程使用，才可以保证其正确性
• 原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可被打乱或缺省

5.2 同步代码块

synchronized（同步监视器）

• 必须是引用数据类型，不能是基本数据类型
• 也可以创建一个专门的同步监视器，没有任何业务含义 （new Object）
• 一般使用共享资源做同步监视器即可
• 在同步代码块中不能改变同步监视器对象的引用
• 尽量不要String和包装类Integer做同步监视器，建议使用final修饰同步监视器

对卖票案例改进

public class BuyTicketRunnable implements Runnable{
	static Object obj=new Object();
	private int ticketNum=10;
	@Override
	public void run() {
		for(int i=1;i<blockquote><ul>
<li>多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块</li>
<li>多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块</li>
</ul></blockquote><h2>5.3 同步方法</h2><blockquote>
<p><code>synchronized</code>（同步方法）</p>
<ul>
<li>不要将run()定义为同步方法</li>
<li>非静态同步方法的同步监视器是this；静态同步方法（static）的同步监视器是 类名.class 字节码信息对象</li>
<li>同步代码块的效率要高于同步方法（原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部）</li>
<li>同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块</li>
</ul>
</blockquote><p><strong>买票案例改进</strong></p><pre class="brush:php;toolbar:false">public class BuyTicketRunnable implements Runnable{
	private int ticketNum=10;
	@Override
	public void run() {
		for(int i=1;i0) {
			System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
			ticketNum--;	
		}
	}}

5.4 Lock锁

Lock锁：

• DK1.5后新增新一代的线程同步方式:Lock锁，与采用synchronized相比，lock可提供多种锁方案，更灵活
• synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。
  但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。

对买票案例改进

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class BuyTicketRunnable implements Runnable{
	private int ticketNum=10;
	Lock lock=new ReentrantLock();//接口=实现类  可以使用不同的实现类
	@Override
	public void run() {
		for(int i=1;i0) {
					System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！");
					ticketNum--;	
				}
			}catch(Exception e) {
				e.printStackTrace();
			}finally {
				 //关闭锁：--->即使有异常，这个锁也可以得到释放
				lock.unlock();
			}
		}
	}}

Lock和synchronized的区别

• Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

5.5 线程死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
• 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

*案例：男孩女孩一起去吃饭，但是桌子上只有两根筷子，如果两个人同时抢到一根筷子而不放弃，这样两个人都吃不上饭，这样就形成死锁了；必须要有一个人放弃争抢，等待另一个人用完，释放资源，这个人之后才会获得两根筷子，两个人才能都吃上饭 *

package 多线程;class Eat{
    //代表两个筷子
	public static Object o1=new Object();
	public static Object o2=new Object();
	public static void eat() {
		System.out.println("可以吃饭了");
	}}class BoyThread extends Thread{
	public void run() {
		synchronized (Eat.o1) {
			System.out.println("男孩拿到了第一根筷子！");
			synchronized (Eat.o2) {
				System.out.println("男孩拿到了第二根筷子！");
				Eat.eat();
			}
		}
	}}class GirlThread extends Thread{
	public void run() {
		synchronized (Eat.o2) {
			System.out.println("女孩拿到了第二根筷子！");
			synchronized (Eat.o1) {
				System.out.println("女孩拿到了第一根筷子！");
				Eat.eat();
			}
		}
	}}public class MyLock {
	public static void main(String[] args) {
		BoyThread boy=new BoyThread();
		GirlThread girl=new GirlThread();
		boy.start();
		girl.start();
	}}

结果

解决办法

先让男孩拿到筷子，线程休眠一下，等待男孩用完筷子，在启动女孩线程

public class MyLock {
	public static void main(String[] args) {
		BoyThread boy=new BoyThread();
		GirlThread girl=new GirlThread();
		boy.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		girl.start();
	}}

在写程序中要避免这种死锁：减少同步资源的定义，避免嵌套同步

六、线程通信问题

在Java对象中，有两种池

• 锁池（synchronized）
• 等待池（wait();notify();notifyAll()）

如果一个线程调用了某个对象的wait方法，那么该线程进入到该对象的等待池中（并且已经将锁释放）；
如果未来的某个时刻，另外一个线程调用了相同的对象notify方法或者notifyAll方法，那么该等待池中的线程就会被唤醒，然后进入到对象的锁池里面去获得该对象的锁；
如果获得锁成功后，那么该线程就会沿着wait方法之后的路径继续执行。注意：沿着wait方法之后执行

6.1 wait()和wait(long timeout)

• wait()：的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，当前线程被唤醒(进入就绪状态)
• wait(long timeout)：让当前线程处于“等待(阻塞)状态，直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入就绪状态)

sleep和wait的区别：sleep进入阻塞状态没有释放锁，wait进入阻塞状态但是同时释放了锁

6.2 notify()和notifyAll()

notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程

• notify()是唤醒单个线程
• notifyAll()是唤醒所有的线程

6.3 生产者和消费者问题

案例：
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

功能分解一：商品类

public class Product {//商品类
    private String name;//名字
    private String brand;//品牌
    boolean flag = false;//设置标记，false表示商品没有，等待生产者生产

    public synchronized void setProduct(String name, String brand) {//生产商品，同步方法，锁住的是this
        if (flag == true) {//如果flag为true，代表有商品，不生产，等待消费者消费
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //生产商品
        this.setName(name);
        this.setBrand(brand);

        System.out.println("生产者生产了" +this.getBrand() +this.getName());
        //生产完，设置标志
        flag = true;
        //唤醒消费线程
        notify();
    }

    public synchronized void getProduct() {
        if (flag == false) {//如果是false，则没有商品，等待生产者生产
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有商品，消费
        System.out.println("消费者消费了" + this.getBrand() +this.getName());
        //设置标志
        flag = false;
        //唤醒线程
        notify();
    }


    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }}

功能分解二：生产者线程

public class ProducterThread extends Thread {//生产者线程
    private Product p;

    public ProducterThread(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        for (int i = 1; i <p><strong>功能分解三：消费者线程</strong></p><pre class="brush:php;toolbar:false">public class CustomerThread extends Thread {//消费者线程
    private Product pro;

    public CustomerThread(Product pro) {
        this.pro = pro;
    }

    @Override
    public void run() {
        for (int i = 1; i <p><strong>功能分解四：测试类</strong></p><pre class="brush:php;toolbar:false">public class Test {
    public static void main(String[] args) {
        Product p = new Product();
        ProducterThread pth = new ProducterThread(p);
        CustomerThread cth = new CustomerThread(p);
        pth.start();
        cth.start();
    }}

结果：生产者生产一件商品，消费者消费一件商品，交替进行

Empfohlenes Lernen: „Java-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über den Java-Multithreading-Mechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!