2. 程式人生 > >自定義執行緒 生產者消費者 join方法

自定義執行緒 生產者消費者 join方法

阿新 • • 發佈：2018-11-02
1. 

/*
 * 1.自定義一個類實現Runnable介面
 * 2.實現Runnable介面的run方法，自定義執行緒的任務放在run方法中
 * 3.建立Runnable實現類物件
 * 4.建立Thread物件，並把Runnable的物件作為實參傳遞給，建構函式
 * 5.呼叫Thread的run方法開啟一個程序
 * */
public class RunablePractice implements Runnable
{
	int num = 50;//不用static即可
	public void run() 
	{
		while(true)
		{
			synchronized ("鎖") 
			{
				if(num>0)
				{
					System.out.println(Thread.currentThread().getName()+"賣出了第"+num--+"張票");
					try 
					{
						Thread.sleep(10);
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
				else
				{
					System.out.println("賣完了");
					break;
				}
			}
		}
	}
	public static void main(String[] args) 
	{
		RunablePractice r = new RunablePractice();
		Thread t1 = new Thread(r,"視窗1");
		Thread t2 = new Thread(r,"視窗2");
		Thread t3 = new Thread(r,"視窗3");
		t1.start();
		t2.start();
		t3.start();
	}
}



執行結果：


視窗1賣出了第50張票
視窗3賣出了第49張票
視窗3賣出了第48張票
視窗2賣出了第47張票
視窗2賣出了第46張票
視窗3賣出了第45張票
視窗3賣出了第44張票
視窗1賣出了第43張票
視窗3賣出了第42張票
視窗2賣出了第41張票
視窗3賣出了第40張票
視窗3賣出了第39張票
視窗1賣出了第38張票
視窗1賣出了第37張票
視窗3賣出了第36張票
視窗3賣出了第35張票
視窗2賣出了第34張票
視窗2賣出了第33張票
視窗2賣出了第32張票
視窗3賣出了第31張票
視窗3賣出了第30張票
視窗3賣出了第29張票
視窗1賣出了第28張票
視窗3賣出了第27張票
視窗2賣出了第26張票
視窗2賣出了第25張票
視窗2賣出了第24張票
視窗2賣出了第23張票
視窗3賣出了第22張票
視窗3賣出了第21張票
視窗3賣出了第20張票
視窗1賣出了第19張票
視窗1賣出了第18張票
視窗1賣出了第17張票
視窗3賣出了第16張票
視窗3賣出了第15張票
視窗3賣出了第14張票
視窗3賣出了第13張票
視窗3賣出了第12張票
視窗2賣出了第11張票
視窗2賣出了第10張票
視窗2賣出了第9張票
視窗2賣出了第8張票
視窗2賣出了第7張票
視窗3賣出了第6張票
視窗1賣出了第5張票
視窗1賣出了第4張票
視窗1賣出了第3張票
視窗3賣出了第2張票
視窗2賣出了第1張票
賣完了
賣完了
賣完了
2. 

import java.util.Random;


class Product 
{
	double price;
	String name;
	boolean flag = false;
	public Product(){}
	public Product(String name, double price)
	{
		this.name = name;
		this.price = price;
	}
}


//wait notify
//wait和notify是屬於Object物件
//必須要在同步程式碼塊或者是同步函式中才能使用
//必須由鎖物件呼叫


class Producer implements Runnable
{
	Random random = new Random();
	int a;
	Product p;
	public Producer(Product p)
	{
		this.p = p;
	}
	public void run()
	{
		while(true)
		{
			synchronized(p) 
			{
				if(p.flag==false)
				{
					a = random.nextInt(2);
					if(a==0)
					{
						p.name = "蘋果";
						p.price = 3.2;
					}
					else
					{
						p.name = "香蕉";
						p.price = 7.3;
					}
					p.flag = true;
					System.out.println("生產了一個"+p.name+"，價格為："+p.price+"....喚醒消費者....");	
					p.notify();
				}
				else
				{
					System.out.println("正在等待消費者");
					try 
					{
						p.wait();
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
			}
		}
	}
}


class Consumer implements Runnable
{
	Product p;
	public Consumer(Product p)
	{
		this.p = p;
	}
	public void run() 
	{
		while(true)
		{
			synchronized(p)
			{
				if(p.flag==true)
				{
					System.out.println("消費者正在消費...");
					try 
					{
						Thread.sleep(1000);
					} 
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
					System.out.println("消費者消費了一個產品！！！....喚醒生產者.....");
					p.flag = false;
					p.notify();
				}
				else 
				{
					System.out.println("等待生產者");
					try {
						p.wait();
					} catch (InterruptedException e) {
						// TODO 自動生成的 catch 塊
						e.printStackTrace();
					}
				}
			}
		}
	}
}


public class ProducerConsumer
{
	public static void main(String[] args) 
	{
		Product t = new Product();
		Producer p = new Producer(t);
		Consumer c = new Consumer(t);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
 		t1.start();
 		t2.start();
	}
}


執行結果：


生產了一個香蕉，價格為：7.3....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
等待生產者
生產了一個香蕉，價格為：7.3....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
等待生產者
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
等待生產者
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
生產了一個香蕉，價格為：7.3....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
等待生產者
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...
消費者消費了一個產品！！！....喚醒生產者.....
等待生產者
生產了一個蘋果，價格為：3.2....喚醒消費者....
正在等待消費者
消費者正在消費...


3.守護執行緒 



public class HouProcess extends Thread
{
	public HouProcess(String name)
	{
		super(name);
	}
	public void run() 
	{
		for(int i = 1;i<=100;i++)
		{
			System.out.println("更新包已經下載了"+i+"%");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("更新包下載完成，等待安裝");
	}
	public static void main(String[] args) 
	{
		HouProcess h = new HouProcess("後臺程序");
		h.setDaemon(true);//讓h執行緒成為守護執行緒
		System.out.println("是守護程序嗎？ "+h.isDaemon());
		h.start();
		for(int i = 1;i<=100;i++)
		{
			System.out.println("main"+i);
		}
	}
}


是守護程序嗎？ true
main1
main2
main3
main4
更新包已經下載了1%
main5
main6
main7
main8
main9
main10
main11
main12
main13
main14
main15
main16
main17
main18
main19
main20
main21
main22
main23
main24
main25
main26
main27
main28
main29
main30
main31
main32
main33
main34
main35
main36
main37
main38
main39
main40
main41
main42
main43
main44
main45
main46
main47
main48
main49
main50
main51
main52
main53
main54
main55
main56
main57
main58
main59
main60
main61
main62
main63
main64
main65
main66
main67
main68
main69
main70
main71
main72
main73
main74
main75
main76
main77
main78
main79
main80
main81
main82
main83
main84
main85
main86
main87
main88
main89
main90
main91
main92
main93
main94
main95
main96
main97
main98
main99
main100
4. 



class Mom extends Thread
{
	public void run() {
		System.out.println("洗菜炒菜");
		System.out.println("沒有醬油了....");
		System.out.println("叫兒子打醬油");
		Son s = new Son();
		s.start();
		try {
			s.join();//兒子加入執行緒,老媽暫停
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("繼續炒菜");
		System.out.println("一起吃飯");
	}
}


class Son extends Thread 
{
	public void run() {
		System.out.println("兒子跑去買醬油...");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("買回來了");
	}
}


public class Join1 {
	public static void main(String[] args) {
		Mom m = new Mom();
		m.start();
	}
}


執行結果：


洗菜炒菜
沒有醬油了....
叫兒子打醬油
兒子跑去買醬油...
買回來了
繼續炒菜
一起吃飯
 

相關推薦

自定義執行緒 生產者消費者 join方法

1. /* * 1.自定義一個類實現Runnable介面 * 2.實現Runnable介面的run方法，自定義執行緒的任務放在run方法中 * 3.建立Runnable實現類物件 * 4.建立Thread物件，並把Runnable的物件作為實參傳遞給，建構函式 * 5.呼叫T

java自定義執行緒（兩種方法）

知識點總結 java中的執行緒模型：一個虛擬cpu，多個執行緒 static start方法：啟動執行緒而非執行執行緒（僅僅告訴虛擬機器，該執行緒已經準備完畢，cup決定執行緒執行的時刻） static sleep方法：在制定的毫秒數

實現為fork/join框架生成自定義執行緒的ThreadFactory介面

Java 9併發程式設計指南 目錄 實現為fork/join框架生成自定義執行緒的ThreadFactory介面 準備工作 實現過程 工作原理 擴充套件學習 更多關注 fork/join框架是Java9中最有趣的特性之一，它是E

多執行緒--生產者消費者範例，使用lock和condition

        上一篇的部落格已經介紹了生產者和消費者，最後還是遺留了一個問題，就是必須Notifyall才能保證喚醒對方執行緒，這樣降低了效率，那麼，有沒有什麼辦法可以指定我們來喚醒哪一個執行緒呢？   &

2.3四種執行緒連線池的配置和使用（和自定義執行緒池）

四種執行緒連線池的配置和使用 最終呼叫類和方法 {引數有 核心執行緒數目，最大執行緒數目，存活時間（當前執行緒執行完這個任務之後，等待下一個任務到來的最長等待時間。如果在這個時間內沒有新的任務來到，那當前執行緒就會退出），時間單位，等待佇列（用於存放待執行的任務）} public

實現ThreadFactory介面生成自定義執行緒

Java 9併發程式設計指南 目錄 實現ThreadFactory介面生成自定義執行緒 準備工作 實現過程 工作原理 擴充套件學習 在面向物件程式設計領域中，工廠模式是廣泛使用的設計模式，創造性的通過開發類來建立一個或多個類的物件。當

Python 自定義執行緒池

"""思路1，將任務放在佇列 1）建立佇列：（初始化） 2）設定大小，執行緒池的最大容量 3）真實建立的執行緒 列表 4）空閒的執行緒數量2，著手開始處理任務 1）建立執行緒 2）空閒執行緒數量大於0，則不再建立執行緒 3）建立執行緒池的數量 不能高於

Java多執行緒-生產者消費者模式

問題描述 有一群生產者程序在生產產品，並將這些產品提供給消費者程序去消費。為使生產者程序與消費者程序能併發執行，在兩者之間設定了一個具有n個緩衝區的緩衝池，生產者程序將它所產生的產品放入緩衝區中，消費者程序可以從一個緩衝區中取走產品去消費。儘管所有的生產者和消費

自定義執行緒池、內建執行緒池.md

自定義簡單執行緒池 python執行緒是可以重複利用的，如果呼叫的時候每次都建立一個執行緒，則太浪費資源了 我把多執行緒比作服務員，每次有客人來的時候，都分配一個專門的服務員去服務； 當客人走了之後，服務員回到空閒狀態，繼續等待新的客人 import threa

Spring Boot 基礎系列教程 | 第三十二篇：使用@Async實現非同步呼叫：自定義執行緒池

推薦 Spring Boot/Cloud 視訊： 在之前的Spring Boot基礎教程系列中，已經通過《Spring Boot中使用@Async實現非同步呼叫》一文介紹過如何使用@Async註解來實現非同步呼叫了。但是，對於這些非同步執行的控制是我們保障自身

通過追女孩子案例模擬Thread類、Runnable介面、自定義執行緒類之間的關係

我們知道，在Thread類、Runnable介面、自定義執行緒類之間實現了靜態代理的設計模式，以下進行簡單的模擬，方便我們對執行緒和靜態代理的一個更加具象的認識。 被人追介面beiRenZhui（Runnable）： /* * 本介面是被人追介面，每一個女孩子都有被人追的特性， * 所以

自定義執行緒池Executors

在使用有界佇列時，若有新的任務需要執行，如果執行緒池實際執行緒數小於corePoolSize，則優先建立執行緒，若大於corePoolSize，則會將任務加入佇列，若佇列已滿，則在匯流排程數不大於maximumPoolSize的前提下，建立新的執行緒，若執行緒數

Java 多執行緒 自定義執行緒輔助

之前的文章我介紹了C#版本的多執行緒和自定義執行緒處理器。 接下來我們來看看Java版本的呢 java 的執行緒和C#的執行緒有點區別，java的執行緒沒有是否是後臺執行緒一說，具體原因是java的執行緒是jvm的c++程式碼模擬執行緒，而C#的執行緒也是C++模擬執行緒。但是區別在於C#的執行緒會基於系

看我是如何處理自定義執行緒模型---java

看過我之前文章的園友可能知道我是做遊戲開發，我的很多思路和出發點是按照遊戲思路來處理的，所以和web的話可能會有衝突，不相符合。 來說說為啥我要自定義執行緒模型呢？ 按照我做的mmorpg或者mmoarpg遊戲劃分，執行緒被劃分為，主執行緒，全域性同步執行緒，聊天執行緒，組隊執行緒，地圖執行緒，以及地圖訊

Java併發程式設計：Java的四種執行緒池的使用，以及自定義執行緒工廠

目錄 引言 四種執行緒池 newCachedThreadPool：可快取的執行緒池 newFixedThreadPool：定長執行緒池 newSingleThreadExecutor：單執行緒執行緒池 newScheduledThreadPool：支援定時的定

Java的四種執行緒池的使用，以及自定義執行緒工廠

四種執行緒池 四種執行緒池分別是：newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ，下面對這幾個執行緒池一一講解。 newCachedThreadPool：可快取的執行緒

Java併發程式設計中四種執行緒池及自定義執行緒使用教程

引言 通過前面的文章，我們學習了Executor框架中的核心類ThreadPoolExecutor ，對於執行緒池的核心排程機制有了一定的瞭解，並且成功使用ThreadPoolExecutor 建立了執行緒池。 而在Java中，除了ThreadPoolExecutor ，Executor框

Java多執行緒——生產者消費者模型-演義

這裡主要解讀（亂侃）生產者消費者模型的工作方式以及JDK5.0新增實現和傳統同步關鍵字實現方式的區別。 在JDK5.0新增了Lock、Condition這兩個介面來處理多執行緒安全問題。 Lock：可替代synchronized實現的同步函式或同步程式碼塊。 Conditi

八、JAVA多執行緒：執行緒池原理以及自定義執行緒池 ThreadPool

為什麼會需要執行緒池技術？ (1)Thread是一個重量級的資源，它的建立，啟動以及銷燬都是比較耗費效能的；重複利用執行緒，減少執行緒建立，銷燬的開銷，是一種好的程式設計習慣。 (2)通過new Thread的方法建立執行緒難以管理，並且難以控制數量，執行緒的數量通常和系統的效能呈拋

java自定義執行緒池--ThreadPoolExecutors

public class MyThreadPool { public static void main(String[] args) { /** * 1.在使用有界佇列的時候：若有新的任務需要執行，如果執行緒池實際執行緒數小於corePoolSize核心執行緒數的時候，則優先建立執行緒。