从java多线程实现“生产者-消费者”模型来谈谈操作系统中线程状态的转换及线程同步的总结

最新推荐文章于 2023-06-24 20:31:25 发布
最新推荐文章于 2023-06-24 20:31:25 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： java基础 文章标签： Java 多线程

转载自：http://blog.csdn.net/fengzhe0411/article/details/6949622

 

前言：自己尝试着用java多线程实现了操作系统原理中讲到的“生产者-消费者”模型，在这里和大家分享一下遇到的问题和心得。我们姑且模糊“线程”和“进程”的区别，只记住它们都是可并发执行的一组过程即可。

一、什么是“生产者-消费者”模型？

             

           这个模型所描述的是假设有一个能容纳N个产品的工厂，生产者进程不断向工厂中输入产品，而消费者进程不断从工厂中取走产品。尽管所有的生产者和消费者都是已异步的方式运行的，但它们之间必须保持同步，即不允许消费者进程到一个空的工厂中取产品，也不允许生产者进程向一个已经装满产品的工厂投放产品。

 

二、用java多线程实现“生产者-消费者”模型（详细代码）

 

[java] view plain copy print ?
  1. package cn.uestc.fz;  
  2.   
  3. public class ProducerConsumer {  
  4.     public static void main(String[] args) {  
  5.         Factory factory = new Factory(0);  
  6.         ProducerThread pt1 = new ProducerThread(factory, 10);  
  7.         ProducerThread pt2 = new ProducerThread(factory, 10);  
  8.         ProducerThread pt3 = new ProducerThread(factory, 10);  
  9.         ConsumerThread ct1 = new ConsumerThread(factory, 10);  
  10.         ConsumerThread ct2 = new ConsumerThread(factory, 10);  
  11.         ConsumerThread ct3 = new ConsumerThread(factory, 10);  
  12.         pt1.setName("生产者1号");  
  13.         pt2.setName("生产者2号");  
  14.         pt3.setName("生产者3号");  
  15.         ct1.setName("消费者1号");  
  16.         ct2.setName("消费者1号");  
  17.         ct3.setName("消费者1号");  
  18.         pt1.start();  
  19.         pt2.start();  
  20.         pt3.start();  
  21.         ct1.start();  
  22.         ct2.start();  
  23.         ct3.start();  
  24.     }  
  25.   
  26. }  
  27.   
  28. /*工厂类*/  
  29. class Factory{  
  30.     private static final int MAX_NUMBER=100;  
  31.     private int currentNumber;  
  32.       
  33.     public Factory(int currentNumber) {  
  34.         super();  
  35.         this.currentNumber = currentNumber;  
  36.     }  
  37.   
  38.     public void add(int produceNumber){  
  39.         //同步方法，保证向工厂添加产品操作是互斥的  
  40.         synchronized(this){  
  41.         while(currentNumber+produceNumber>MAX_NUMBER){  
  42.             System.out.println(Thread.currentThread().getName()+":当前生产过剩！无法投放！");  
  43.             try {  
  44.                 wait();  
  45.             } catch (InterruptedException e) {  
  46.                 // TODO Auto-generated catch block  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.         currentNumber+=produceNumber;  
  51.         System.out.println(Thread.currentThread().getName()+":投放了"+produceNumber+"个产品，当前工厂里产品的数量为："+currentNumber);  
  52.         notifyAll();  
  53.         }  
  54.         try {  
  55.             Thread.sleep(100);//休眠0.1秒，好让其它线程有机会运行  
  56.         } catch (InterruptedException e) {  
  57.             // TODO Auto-generated catch block  
  58.             e.printStackTrace();  
  59.         }  
  60.     }  
  61.       
  62.     public void get(int consumeNmber){  
  63.         //同步方法，保证从工厂消费产品操作是互斥的  
  64.         synchronized(this){  
  65.         while(currentNumber<consumeNmber){  
  66.             System.out.println(Thread.currentThread().getName()+":工厂剩余产品不足！无法消费！");  
  67.             try {  
  68.                 wait();  
  69.             } catch (InterruptedException e) {  
  70.                 // TODO Auto-generated catch block  
  71.                 e.printStackTrace();  
  72.             }  
  73.         }  
  74.         currentNumber-=consumeNmber;  
  75.         System.out.println(Thread.currentThread().getName()+":消费了"+consumeNmber+"个产品，当前工厂里产品的数量为："+currentNumber);  
  76.         notifyAll();  
  77.         }  
  78.         try {  
  79.             Thread.sleep(100);//休眠0.1秒，好让其它线程有机会运行  
  80.         } catch (InterruptedException e) {  
  81.             // TODO Auto-generated catch block  
  82.             e.printStackTrace();  
  83.         }  
  84.     }  
  85. }  
  86.   
  87. /*生产者线程*/  
  88. class ProducerThread extends Thread{  
  89.     private Factory factory;  
  90.     private int produceNumber; //一次投放的产品个数  
  91.     public ProducerThread(Factory factory,int produceNumber){  
  92.         this.factory=factory;  
  93.         this.produceNumber=produceNumber;  
  94.     }  
  95.       
  96.     public void run(){  
  97.         while(true)  
  98.             factory.add(produceNumber);  
  99.     }  
  100. }  
  101.   
  102. /*消费者线程*/  
  103. class ConsumerThread extends Thread{  
  104.     private Factory factory;  
  105.     private int consumerNumber; //一次取出的产品个数  
  106.     public ConsumerThread(Factory factory, int consumerNumber) {  
  107.         this.factory = factory;  
  108.         this.consumerNumber = consumerNumber;  
  109.     }  
  110.       
  111.     public void run(){  
  112.         while(true)  
  113.             factory.get(consumerNumber);  
  114.     }  
  115. }  
package cn.uestc.fz;

public class ProducerConsumer {
	public static void main(String[] args) {
		Factory factory = new Factory(0);
		ProducerThread pt1 = new ProducerThread(factory, 10);
		ProducerThread pt2 = new ProducerThread(factory, 10);
		ProducerThread pt3 = new ProducerThread(factory, 10);
		ConsumerThread ct1 = new ConsumerThread(factory, 10);
		ConsumerThread ct2 = new ConsumerThread(factory, 10);
		ConsumerThread ct3 = new ConsumerThread(factory, 10);
		pt1.setName("生产者1号");
		pt2.setName("生产者2号");
		pt3.setName("生产者3号");
		ct1.setName("消费者1号");
		ct2.setName("消费者1号");
		ct3.setName("消费者1号");
		pt1.start();
		pt2.start();
		pt3.start();
		ct1.start();
		ct2.start();
		ct3.start();
	}

}

/*工厂类*/
class Factory{
	private static final int MAX_NUMBER=100;
	private int currentNumber;
	
	public Factory(int currentNumber) {
		super();
		this.currentNumber = currentNumber;
	}

	public void add(int produceNumber){
		//同步方法，保证向工厂添加产品操作是互斥的
		synchronized(this){
		while(currentNumber+produceNumber>MAX_NUMBER){
			System.out.println(Thread.currentThread().getName()+":当前生产过剩！无法投放！");
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		currentNumber+=produceNumber;
		System.out.println(Thread.currentThread().getName()+":投放了"+produceNumber+"个产品，当前工厂里产品的数量为："+currentNumber);
		notifyAll();
		}
		try {
			Thread.sleep(100);//休眠0.1秒，好让其它线程有机会运行
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public void get(int consumeNmber){
		//同步方法，保证从工厂消费产品操作是互斥的
		synchronized(this){
		while(currentNumber<consumeNmber){
			System.out.println(Thread.currentThread().getName()+":工厂剩余产品不足！无法消费！");
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		currentNumber-=consumeNmber;
		System.out.println(Thread.currentThread().getName()+":消费了"+consumeNmber+"个产品，当前工厂里产品的数量为："+currentNumber);
		notifyAll();
		}
		try {
			Thread.sleep(100);//休眠0.1秒，好让其它线程有机会运行
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

/*生产者线程*/
class ProducerThread extends Thread{
	private Factory factory;
	private int produceNumber; //一次投放的产品个数
	public ProducerThread(Factory factory,int produceNumber){
		this.factory=factory;
		this.produceNumber=produceNumber;
	}
	
	public void run(){
		while(true)
			factory.add(produceNumber);
	}
}

/*消费者线程*/
class ConsumerThread extends Thread{
	private Factory factory;
	private int consumerNumber; //一次取出的产品个数
	public ConsumerThread(Factory factory, int consumerNumber) {
		this.factory = factory;
		this.consumerNumber = consumerNumber;
	}
	
	public void run(){
		while(true)
			factory.get(consumerNumber);
	}
}

 

运行结果：

生产者1号:投放了10个产品，当前工厂里产品的数量为：10
生产者2号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
消费者1号:工厂剩余产品不足！无法消费！
生产者3号:投放了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者2号:投放了10个产品，当前工厂里产品的数量为：10
生产者1号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者3号:投放了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者2号:投放了10个产品，当前工厂里产品的数量为：10
生产者1号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
生产者3号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者1号:投放了10个产品，当前工厂里产品的数量为：10
生产者2号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者3号:投放了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者1号:投放了10个产品，当前工厂里产品的数量为：10
生产者2号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
生产者3号:投放了10个产品，当前工厂里产品的数量为：20
消费者1号:消费了10个产品，当前工厂里产品的数量为：10
消费者1号:消费了10个产品，当前工厂里产品的数量为：0
生产者2号:投放了10个产品，当前工厂里产品的数量为：10

......

理想状态下此程序应该会源源不断的运行着。


 

 三、关于操作系统中的进程（or线程）转换的三种状态

 

        现代操作系统一般采用分时操作系统，也就是说进程（or线程）在计算机上运行都是分时间片的，计算机的时间被划分为一个个细小的时间片，分给需要运行的进程（or线程）用。这里必须要清楚的是，在单CPU的计算机上，同一时间只能有一个进程（or线程）在运行，这就是我们说的“并发”，而并不是“并行”。一旦某个进程（or线程）用完时间片之后，它会退回到“就绪”状态，而如果运行的中途出现问题，如缺少资源而导致无法运行的时候，它就会变成阻塞的状态。这个时候操作系统的调度程序会根据某种调度算法来将就绪队列中的一个进程（or线程）提升为运行状态。而那个被阻塞的进程（or线程）在得到它所缺少的资源后会变为就绪状态，等待调度程序把它调度执行。

 

四、为什么要用Thread类的静态方法sleep让当前的进程休眠？

       我们知道，其实各个进程（or线程）就是切换着运行的，但是为了让我们观察的更明显，每次完成一次取出或者投放操作，都让当前的线程休眠掉，这样子其它线程就有就会执行。当当前的线程执行sleep操作后，相当于把它给阻塞掉了（此时这个线程的时间片也许并没有用完），sleep的参数是毫秒。也就是说这个毫秒的时间过后，操作系统会给此线程一个信号（相当于缺少的资源）说你的时间到了，然后把它变为就绪状态等待新一轮的调度。（注意就算sleep后的时间到了，该线程可能也不会马上运行，只能说它有了运行的机会）

 

五、为什么Factory类中add和get方法要加synchronized同步块？

       这里就要介绍操作系统中“临界区”的概念了，“临界资源”指的是各进程互斥的共享的资源，也就是我有的时候你不能有，你有的时候我不能有的东西，但是当我没有了，你就可以有了。而“临界区”就是对“临界资源”访问的那段代码，显然我们要求一次只能有一个进程或者线程访问这段代码。在java中每个对象都有唯一的一把“锁”，当某个线程得到这把锁的时候，其它线程只能在外面徘徊，直到这个线程放弃这把锁，其它等待锁的线程再去竞争这把锁。

      那么如果我们不使用synchronized同步块会怎么样呢？如果当前工厂中有0个产品，这时有一个生产者线程pt1执行了“currentNumber+=produceNumber”的操作，碰巧这个时候线程发生切换，另一个生产者线程pt2也执行了“currentNumber+=produceNumber”的操作，然后线程再次切换回pt1，此时打印出来的是“生产者1号:投放了10个产品，当前工厂里产品的数量为：20”，其实正确的应该结果是“10”。这显然是不对的。

     而当加了synchronized同步块后，线程pt1拥有factory对象的锁，此时pt2是无法运行这段代码的，它只能等待pt1释放了这把锁再去执行。

 

六、wait方法和notifyAll方法是怎么用的？

      这几个方法都是存在于Object类中的。

     

wait

public final void wait()
                throws InterruptedException
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用： 

synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
     }
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

 

notify

public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

  • 通过执行此对象的同步实例方法。
  • 通过执行在此对象上进行同步的 synchronized 语句的正文。
  • 对于 Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

notifyAll

public final void notifyAll()
唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

    

 

        首先我们必须明白，以上几个方法必须在同步方法或者同步代码块中调用，否则会抛出java.lang.IllegalMonitorStateException的异常。也就是说，在线程执行以上几个方法的时候，它必须拥有该对象的锁（一次只能有一个线程拥有对象的监视器）。

        当在对象上调用wait方法时，执行该代码的线程立即放弃它在对象上面的锁。然后当调用notify时，并不意味着调用notify的线程会立即放弃其锁。如果此线程仍然在完成同步代码，则线程在执行完这段代码后才会放弃其锁。因此，调用notify方法时并不意味着这时该锁变得可用。我们可以看到API上面的解释是：直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。参考：http://blog.csdn.net/iceman1952/article/details/2159812

多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。

以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：

线程A：

synchronized(obj) {
    while(!condition) {
        obj.wait();
    }
    obj.doSomething();
}

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。

在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

线程B：

synchronized(obj) {
    condition = true;
    obj.notify();
}

需要注意的概念是：

1、调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在      synchronized(obj) {...}代码段内。

即：

obj.wait(), obj.notify()必须在synchronized(obj){}内部，也就是说，必须得先得到锁才可以wait, nofity

2、主调obj.wait()的线程（线程A），在obj.wait()执行时，释放掉锁

3、线程A再次运行时，必须要得到锁，而且，这次运行是从obj.wait()后的第一条语句开始的（当然不包括obj.wait()）

4、如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

5、obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

6、当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

 

     

七、notify和notifyAll的区别

        notify就是在所有wait的线程中选择一个，使它被唤醒；

        notifyAll就是使所有wait的线程被唤醒。

        那么问题就来了，当notify所在的那段同步代码执行完后，释放掉该对象的锁，那么notify唤醒的那个线程就一定会得到该锁吗？我在网上看到很多都是这样说的，我认为这是错误的。我们应该明确，“唤醒”和“得到锁”不是一个概念，“唤醒”只是有机会得到锁罢了，虽然notify只是唤醒一个线程，但是别忘了，可能还有其它的线程要进入synchronized同步块，它们也有可能获得这把锁。API中也说了：被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。

      简单点说：notify使一个wait的线程唤醒，它有机会得到锁，其它wait的线程连得到锁的机会都没；notifyAll使所有wait的线程唤醒，它们都有机会得到锁。

 

八、为什么条件判断要用while而不用if

       我先开始写的时候用的是if，觉得你如果不满足条件，就去等待嘛，然后等着被唤醒然后得到锁。但是别忘了，就算你得到了锁，只是代表你可以运行，并不意味着条件就满足了。比如说，生产者线程1发现工厂满了，等待之，生产者线程2也发现满了，等待，消费者1消费了之后执行notifyALL操作，生产者1和2都被唤醒，1得到了锁执行，它也调用notifyAll，这时2得到了锁，但是它能往工厂添加产品吗？此时工厂又满了啊，所以每次被唤醒，都要再次进行条件判断。

       wait相当于是释放锁之后进入阻塞队列，当被唤醒，且为可执行的时候，就会继续从调用wait方法的那个地方执行。

       这个可能有点绕，简单点说，就是唤醒你的线程并不一定是和你业务逻辑相关的线程，上面的生产者2就是被生产者1唤醒的，而我们想象中可能认为它是被某个消费者线程唤醒的。

 

总结下多线程的同步：

线程的同步分为两种方式：同步块和同步方法

1、同步块

synchronized(object)

{

}

同步块所同步的对象为object参数，获取的是一个对象实例的锁；

要保证在同步object这个对象实例的时候，保证object该引用指向的对象实例是同一个，不然不能获得预期的效果，因为object该引用指向的对象实例若有变化，则同步块获取的锁就不是同一把锁了。

 

2、同步方法

public [static] synchronized void test()

{

}

方法分为静态方法和非静态方法

若是非静态同步方法，则获取的锁相当于是调用该方法的this实例（和同步块的synchronized(this){}效果一样），同样，你要保证每次调用该同步方法的是同一个实例（即同一个this），就像上例中的生产者消费者问题中只有一个factory实例一样。

你若new出很多实例，然后分别调用非静态同步方法，则获取的this的锁不同，同步会失败

若是静态同步方法，对象锁就是该静态方法所在的类的Class（ClassName.class）实例，由于在JVM中，所有被加载的类都有唯一的类对象。不管我们创建了该类的多少实例，但是它的类实例仍然是一个！

 你若new出很多实例，然后分别调用静态同步方法，仍然是可以同步的

 

所以，同步其实上是对临界资源的一种互斥操作，既要达到以同步互斥的方式保护临界资源的目的，同时要明确临界资源的唯一性，对同一临界资源进行操作的同步代码块之间使用的锁的唯一性（使用同一个锁）。竞争同步锁失败的线程进入的是该同步锁的就绪队列。

关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。
关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源（即临界资源）的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。
关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。

liuxigiant
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者消费者问题（操作系统多线程经典问题）
01-18
缓冲区没满：生产者可以生产 缓冲区没空：消费者可以消费 生产消费可以同时进行 生产者、消费者、产品、缓冲区的数量可以自定义
JAVA多线程实现生产者消费者的实例详解
08-30
在JAVA中，实现生产者消费者模型可以使用多线程技术，即生产者线程负责生产产品，而消费者线程负责消费产品。为了确保线程安全，需要使用同步机制来控制对共享资源的访问。 在给定的例子中，使用了三个类：Product...
从java多线程实现“生产者-消费者”模型来谈谈操作系统中线程状态的转换
11-08 4157
前言：自己尝试着用java多线程实现了操作系统原理中讲到的“生产者-消费者”模型，在这里和大家分享一下遇到的问题和心得。我们姑且模糊“线程”和“进程”的区别，只记住它们都是可并发执行的一组过程即可。 一、什么是“生产者-消费者”模型？                          这个模型所描述的是假设有一个能容纳N个产品的工厂，生产者进程不断向工厂中输入产品，而消费者进程不断从工厂中取
线程状态转换
10-30 129
一、线程状态转换 新建（New） 创建后尚未启动。 可运行（Runnable） 可能正在运行，也可能正在等待 CPU 时间片。 包含了操作系统线程状态中的 Running 和 Ready。 阻塞（Blocking） 等待获取一个排它锁，如果其线程释放了锁就会结束此状态。 无限期等待（Waiting） 等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。 ...
操作系统---线程的状态转换
https://juejin.cn/user/4248168663101239/posts
05-22 666
线程的状态一. 线程的状态图二. 线程的状态①. 新建状态(NEW)②. 就绪状态(RUNNABLE/READY)③. 运行中状态(RUNNING)④. 阻塞状态(BLOCKED)⑤. 终止状态(TERMINATED)三. 线程执行中的方法分析①. Thread.sleep(long millis)②. Thread.yield()③. Thread.join()④. obj.wait()⑤. obj.notify()⑥. LockSupport.park() 一. 线程的状态图 二. 线程的状态 ①.
Thread类里的线程状态和操作系统层面的线程状态
salted___fish的博客
06-30 358
五种状态 这是从操作系统层面来描述的。 操作系统层面--线程的生命周期（五种状态）-中文 操作系统层面--线程的生命周期（五种状态）-英文 新建状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联 可运行状态（就绪状态）：指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行 运行状态：指获取了 CPU 时间片运行中的状态 当 CPU 时间片用完，会从运行状态转换至可运行状态，会导致线程的上下文切换 阻塞状态：如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CP
多进程同步方法解决生产者-消费者问题(linux线程实现)
05-15
(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者线程的标识符.(2)生产者和消费者各有两个以上.(3)多个生产者或多个消费者之间须有共享对缓冲区进行操作的...
Java多线程-生产者与消费者问题
最新发布
02-03
### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景：一个是生产者...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，BlockingQueue是Queue的子类，它提供了一个线程安全的队列，可以用于生产者和消费者之间的数据传输。 BlockingQueue的实现类有多种，常见的有...
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...
线程的状态转换以及基本操作
不喝枸杞的程序员
11-07 158
新人大礼包，30G Java架构资料，免费领取 在上一篇文章中 解读并发编程的优缺点 谈到了为什么花功夫去学习并发编程的技术，也就是说我们必须了解到并发编程的优缺点，我们在什么情况下可以去考虑开启多个线程去实现我们的业务，当然使用多线程我们应该着重注意一些什么，在上一篇文章中会有一些讨论。那么，说了这么多，无论是针对面试还是实际工作中作为一名软件开...
【操作系统】线程状态
博客
08-07 598
线程状态 作用：辅助线程进行调度 通过代码来显示一下各种线程状态 public class ThreadDemo1 { public static void main(String[] args) { for (Thread.State state : Thread.State.values()){ System.out.println(state); } } } Java 中线程的状态是通过一个 enum 来表示.
JAVA 多线程 生产者消费者问题(操作系统实验)
m0_49548571的博客
02-24 144
/** * 生产者消费者 */ public class Demo02 { public static void main(String[] args) { //创建资源 Resource r = new Resource(); //创建生产者 Producer producer1 = new Producer(r); Producer producer2 = new Producer(r); //.
线程的状态及其相互转换
cisco_huang的博客
02-14 833
我们都知道线程的几个状态, 从源码可以看出 不通过代码分析的都是耍流氓~ /** * 线程状态Demo */ public class ThreadStateDemo { public static void main(String[] args) { // NEW // Thread thread = new Thread(); ...
[线程]操作系统线程是怎么切换的（用户态的内部切换）
新一的技术笔记
08-24 7123
前言 多线程，会减少内核态，用户态的切换，从而提高性能。 关于这块得好好学习处理一下。 操作系统（哈工大李治军老师）32讲（全）超清 这个课程中，用户级别线程和内核级别线程的课程之后得看一下。 简述 在没看这个课程之前，为什么要有线程，大概是这样的？ 因为一个进程，要进行多个指令，如果访问地址，需要有地址，要回到映射表中。 执行不下去了，进程要切换，那么一个执行指令序列，要切换到另外一个执行指令序列， 比如A函数 从b函数执行， 那么我们只切换指令，不切换映射表，那么就是线程了。 所
计算机操作系统——复习第二章进程与线程,,第三章处理机调度进程状态、状态转换都有哪些？状态转换各自原因是什么？进程控制块（PCB）中包含哪些信息？这些信息的主要用途是什么？
WZY22502701的博客
06-24 1491
4）时间片调度优先法（时间片为1min）4）时间片调度算法（令时间片2min）4）时间片轮转算法（时间片为5）4）时间片轮转算法（时间片为3）平均周转时间=20.4min。平均周转时间：11.3333。平均周转时间=10.3333。平均周转时间 =40min。平均周转时间：11.75。平均周转时间=10min。平均周转时间：33.75。平均周转时间：26.25。
操作系统-进程与线程（进程的概念、组成、特征、进程的状态与转化）
dodamce的博客
08-01 1110
当进程运行结束后，会执行exit系统调用结束进程，此时进程的状态为终止状态，CPU负责回收进程申请的系统资源和PCB。PID操作系统为了区分不同的进程，当进程创建时，操作系统会给进程创建一个唯一、不重复的编号。当进程创建完成后就会进入就绪状态，就绪状态的进程已经具备运行的条件了，只是此时CPU没有运行这个进程。进入阻塞态的进程当等待的系统资源就绪的时候，会从阻塞态进入就绪态重新等待CPU调度。结构每个进程都会配置一个PCB。此时进程正在等待CPU调度，如果进程被CPU调度，此时进程的状态运行态。......
Java多线程 异步模式之生产者消费者模式
LIUZEYU12A
01-31 352
之前学习过的同步模式是保护性暂停，存在一定的缺陷，我们当初举例是两个线程，线程A收信人，线程B送信人，使用一个信箱充当一个中间过渡的介质。在多任务的情况下，收信人存在多个，发信人就得存在多个，而且只有当送信者将信件送到指定的收信人手中，一个任务才算完成，这中间的操作是同步进行的，因此属于同步模式下的多线程任务。 弊端也很明显，实际情况下，送信者只需要把信件放入信箱通知收信人即可，而不需要等到收信人拿到信才算结束，因为送信人把信收到信箱通知收信人后还可以接着送下一份信件，这中间送信人的时间没有得到充分的利用。
java多线程编程之线程状态的转换
m0_69167817的博客
02-08 138
java中的线程和操作系统中的线程分别存在于虚拟机和操作系统中，线程在创建时，其实是先创建一个java线程，等到本地存储、程序计数器、缓冲区等都分配好以后，JVM会调用操作系统的方法，创建一个与java线程绑定的原生线程。线程对象创建后，其他线程调用了该对象的start() 方法。当操作系统为线程分配好时间片以后，就会调用java线程的run方法执行线程。处于这个状态的线程不会被分配CPU执行时间，它们要等待被其他线程显式唤醒。当线程结束后，会释放java线程和原生线程所占用的资源。
Java多线程解决生产者-消费者问题
生产者线程负责生产数据，而消费者线程负责消费数据，它们共享一个存储数据的对象，通过`write`和`read`操作进行交互。" 在Java中，线程是程序中的并发执行路径，是轻量级的进程。每个线程有自己的程序计数器，但...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值