2. 程式人生 > >JavaSE基礎學習筆記及案例(二)多執行緒(下)與簡單工廠模式的瞭解

JavaSE基礎學習筆記及案例(二)多執行緒(下)與簡單工廠模式的瞭解

阿新 • • 發佈：2018-11-19

1.多執行緒(下)

1.1單例設計模式：保證類在記憶體中只存在一個物件
************餓漢式與懶漢式的區別【面試題】

  1. 餓漢式單例模式：以空間換時間
  2. 懶漢式單例模式：以時間換空間（不推薦使用，僅在面試中用到）
    3.多執行緒訪問時：餓漢式不會建立多個物件；而懶漢式模式有可能會建立多個物件【弊端】
/* @author ZHENG
 *	餓漢式
*/
class Singleton{
	//1.私有構造方法，其他類不能訪問該構造方法
	private Singleton(){
		
	}
	//2.建立本類物件(私有成員變數)
	private static Singleton s = new Singleton();
	//3.對外提供公共的訪問方法
	public static Singleton getInstance(){
		return s;
	}
}

 
/**
 * @author ZHENG
 *	懶漢式:單例延遲載入模式
 */
class Singleton{
	//1.私有構造方法，其他類不能訪問該構造方法
	private Singleton(){
		
	}
	//2.宣告一個引用
	private static Singleton s;
	//3.對外提供公共的訪問方法
	public static Singleton getInstance(){
		if(s==null){
			//執行緒1等待，執行緒2等待
			s=new Singleton();
		}
		return s;
	}
}

1.2第三種單例設計模式
非重點

class Singleton{
	//1.私有構造方法，其他類不能訪問該構造方法
	private Singleton(){
		
	}
	//2.宣告一個引用
	public final static Singleton s=new Singleton();
	
}

1.3多執行緒之RunTime類（瞭解）

public class demo2_Runtime {
	public static  void main(String[] args) throws IOException{
		Runtime r = Runtime.getRuntime();//獲取執行時物件
		/*r.exec("shutdown -s -t 300");//設定電腦5分鐘後關機
*/		r.exec("shutdown -a");
	}
}

1.4多執行緒之Timer類
Timer:一種計時器
TimerTask：建立一個計時器任務

t.schedule(安排的任務，new Date(當前年份-1900，月，日，時，分，秒)，多長時間重複執行) //指定時間執行指定的任務

/**
 * @author ZHENG
 *	timer指定時間安排指定任務
 */
public class demo3_Timer {
	public static void main(String[] args) throws InterruptedException{
		Timer t = new Timer();
		//指定時間安排指定任務
		//t.schedule(安排的任務，new Date(當前年份-1900，月，日，時，分，秒)，多長時間重複執行)
		//2018年11月3日
		t.schedule(new MyTimerTask(), new Date(118,10,3,19,39,10), 3000);
		while(true){
			Thread.sleep(1000);
			System.out.println(new Date());
		}
	}
}
class MyTimerTask extends TimerTask{
	@Override
	public void run() {
		System.out.println("起床了...");
	}
}

1.5多執行緒之執行緒之間的通訊
-------wait方法：其他物件呼叫此物件的notify，導致當前執行緒等待
-------notify:兩個執行緒間的通訊：喚醒等待的單個執行緒
-------notifyAll:多個執行緒間的通訊：喚醒所有執行緒
注意事項：1.在同步程式碼塊中，用哪個物件鎖，就用哪個物件呼叫wait方法；
2.sleep方法和wait方法區別？
—2.1.sleep必須傳入時間引數，時間到了自動醒來；
wait既可以傳入引數，也可以不傳入引數，如果傳入引數就是在引數時間結束後等待，若不傳入引數就是直接等待；
—2.2.sleep方法在同步函式或同步程式碼塊中，不釋放鎖；
wait方法在同步函式或者同步程式碼塊中釋放鎖；
以下程式碼為兩個執行緒之間的通訊
同步程式碼塊使用if判斷

public class demo4_notify {
	/**
	 * @param args
	 * 
	 * 等待喚醒機制
	 */
	public static void main(String[] args){
		final Print p = new Print();
		while(true){
			new Thread(){
				public void run(){
					try {
						p.print1();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
			new Thread(){
				public void run(){
					try {
						p.print2();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
}
class Print{
	private int flag = 1;
	public void print1() throws InterruptedException{
		//非靜態程式碼塊使用this
		synchronized (this) {
			if(flag != 1){
				this.wait();//當前執行緒等待
			}
			System.out.print("好");
			System.out.print("好");
			System.out.print("學");
			System.out.print("習");
			System.out.println();
			flag = 2;
			this.notify();//隨機喚醒單個等待的執行緒
		}
	}
	public void print2() throws InterruptedException{
		//非靜態程式碼塊使用this
		synchronized (this) {
			if(flag != 2){
				this.wait();//當前執行緒等待
			}
			System.out.print("天");
			System.out.print("天");
			System.out.print("向");
			System.out.print("上");
			System.out.println();
			flag = 1;
			this.notify();//隨機喚醒單個等待的執行緒
		}
	}
}

以下程式碼為多個執行緒間通訊，程式碼塊中使用while判斷

public class demo5_notifyAll {


	/**
	 * @param args
	 * 三條執行緒呼叫三個方法:使用while
	 * 等待喚醒機制
	 */
	public static void main(String[] args){
		final PrintAll p = new PrintAll();
		while(true){
			new Thread(){
				public void run(){
					try {
						p.print1();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
			new Thread(){
				public void run(){
					try {
						p.print2();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
			new Thread(){
				public void run(){
					try {
						p.print3();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
}
class PrintAll{
	private int flag = 1;
	public void print1() throws InterruptedException{
		//非靜態程式碼塊使用this
		synchronized (this) {
			while(flag != 1){
				this.wait();//當前執行緒等待
			}
			System.out.print("好");
			System.out.print("好");
			System.out.print("學");
			System.out.print("習");
			System.out.println();
			flag = 2;
			this.notifyAll();//隨機喚醒所有等待的執行緒
		}
	}
	public void print2() throws InterruptedException{
		//非靜態程式碼塊使用this
		synchronized (this) {
			while(flag != 2){
				this.wait();//當前執行緒等待
			}
			System.out.print("天");
			System.out.print("天");
			System.out.print("向");
			System.out.print("上");
			System.out.println();
			flag = 3;
			this.notifyAll();//隨機喚醒所有等待的執行緒
		}
	}
	public void print3() throws InterruptedException{
		//非靜態程式碼塊使用this
		synchronized (this) {
			while(flag != 3){
				this.wait();//當前執行緒等待
			}
			System.out.print("-");
			System.out.print("毛");
			System.out.print("主");
			System.out.print("席");
			System.out.println();
			flag = 1;
			this.notifyAll();//隨機喚醒所有等待的執行緒
		}
	}
}

1.6多執行緒之互斥鎖
-----------ReentrantLock:建立互斥鎖>>>>>>>>>>ReentrantLock r = new ReentrantLock
----r.lock:獲取鎖
----r.unlock:釋放鎖

private ReentrantLock r = new ReentrantLock();//互斥鎖
	private Condition c1 = r.newCondition();//建立3個監視器
	private Condition c2 = r.newCondition();
	private Condition c3 = r.newCondition();

對1.5由synchronized實現的多個執行緒間通訊優化(1.5特性)

public class demo1 {
	public static void main(String[] args){
		final PrintAll p = new PrintAll();
		while(true){
			new Thread(){
				public void run(){
					try {
						p.print1();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
			new Thread(){
				public void run(){
					try {
						p.print2();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
			new Thread(){
				public void run(){
					try {
						p.print3();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
	}
class PrintAll{
	private ReentrantLock r = new ReentrantLock();//互斥鎖
	private Condition c1 = r.newCondition();//建立3個監視器
	private Condition c2 = r.newCondition();
	private Condition c3 = r.newCondition();
	private int flag = 1;
	public void print1() throws InterruptedException{
		r.lock();//獲取鎖
				if(flag != 1){
				c1.await();//c1等待
			}
			System.out.print("好");
			System.out.print("好");
			System.out.print("學");
			System.out.print("習");
			System.out.println();
			flag = 2;
			c2.signal();//喚醒c2
		r.unlock();//釋放鎖
	}
	public void print2() throws InterruptedException{
		r.lock();
			if(flag != 2){
				c2.await();
			}
			System.out.print("天");
			System.out.print("天");
			System.out.print("向");
			System.out.print("上");
			System.out.println();
			flag = 3;
			c3.signal();
		r.unlock();
	}
	public void print3() throws InterruptedException{
		r.lock();
			if(flag != 3){
				c3.await();;
			}
			System.out.print("-");
			System.out.print("毛");
			System.out.print("主");
			System.out.print("席");
			System.out.println();
			flag = 1;
			c1.signal();
		r.unlock();
	}
}

1.7多執行緒的5種狀態【面試題】
在這裡插入圖片描述
1.8執行緒池
1.建立兩個執行緒池
ExecutorService pool = Executors.newFixedThreadPool(2);

2.工廠模式【瞭解】

2.1簡單工廠設計模式【瞭解】
第一步：建立一個抽象的Animal類

public abstract class Animal {

	public abstract void eat();
}

第二步：建立貓和狗類物件繼承自Animal類

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("貓吃魚");
	}

}


public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
}

第三步建立Animal的工廠類

public class Animal_Fac {
	public static Animal creatAnimal(String name){
		if("dog".equals(name)){
			return new Dog();
		}else if("cat".equals(name)){
			return new Cat();
		}else{
			return null;
		}
	}
}

第四步：建立測試類實現簡單工廠模式

public class Test {
	public static void main(String[] args){
		Dog cd = (Dog) Animal_Fac.creatAnimal("dog");
		cd.eat();
		Animal ct = Animal_Fac.creatAnimal("cat");
		ct.eat();
	}
}

2.2工廠方法
第一步：建立動物抽象類，dog類與cat類分別繼承該抽象類，步驟如1.9前三步；
第二步：建立工廠介面

/**
 * @author ZHENG
 *	工廠介面
 */
public interface Fac_Inter {
	public Animal creatAnimal();
}

第三步：分別建立Cat工廠和Dog工廠實現第二步中動物工廠介面

public class Cat_Fac implements Fac_Inter {
	@Override
	public Animal creatAnimal() {
		return new Cat();
	}
}

public class Dog_Fac implements Fac_Inter {
	@Override
	public Animal creatAnimal() {
		return new Dog();
	}
}

第四步：建立測試類，實現程式碼

public class Test {

	public static void main(String[] args) {
		Cat_Fac cf = new Cat_Fac();/*與建立狗工廠方法相同*/
		Dog_Fac df = new Dog_Fac();//建立狗工廠物件
		Dog d = (Dog) df.creatAnimal();//呼叫方法，向下強轉，得狗物件
		d.eat();//狗物件呼叫方法
	}
}

2.3介面卡設計模式
介面卡原理：
1.介面卡就是一個類實現監聽介面，所有抽象方法都被重寫，但是方法是空的；
2.介面卡需要定義成抽象的，因為建立該類物件，呼叫空方法無意義；
3.目的：簡化操作，定義監聽器時繼承介面卡，僅重寫需要的方法即可；

public class shipeiqi {
	public static void main(String[] args){
		
	}
}
interface 和尚{
	public void 打坐();
	public void 唸經();
	public void 撞鐘();
	public void 習武();
}
/**
 * 該類即是介面卡類
 * 
 * 宣告成抽象的，防止其他類呼叫水滸傳裡的方法，因為建立也無意義，方法都是空的
 */
abstract class 水滸傳 implements 和尚{

	@Override
	public void 打坐() {
		
	}

	@Override
	public void 唸經() {
		
	}

	@Override
	public void 撞鐘() {
		
	}

	@Override
	public void 習武() {
		
	}
	
}
/**
 * 魯智深僅有習武這個方法
 * 
 * 如果唐僧實現和尚這個介面，可以通過介面卡，需要哪個方法就重寫哪個方法
  */
class 魯智深 extends 水滸傳{
	public void 習武(){
		System.out.println("倒拔垂楊柳");
		System.out.println("拳打鎮關西");
		System.out.println("......");
	}
}

2.4設計模式之模板（Template）

public class demo2 {
	public static void main(String[] args){
		Demo d = new Demo();
		System.out.println(d.getTime());
	}
}
/**
 * @author 
 *	模板：定義一個框架模型，如需改動更改子類即可
 */
abstract class GetTime{
	public final long getTime(){//子類不可更改該方法
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		return (end-start)/1000;
	}
	public abstract void code();//讓子類可以重寫該方法
}
class Demo extends GetTime{
	@Override
	public void code() {
		for (int i = 0; i < 100000; i++) {
			System.out.println(i);
		}
	}
}

相關推薦

JavaSE基礎學習筆記及案例(二)多執行緒(下)與簡單工廠模式的瞭解

1.多執行緒(下) 1.1單例設計模式：保證類在記憶體中只存在一個物件 ************餓漢式與懶漢式的區別【面試題】 餓漢式單例模式：以空間換時間 懶漢式單例模式：以時間換空間（不推薦使用，僅在面試中用到） 3.多執行緒訪問時：餓漢式不會建立多個物件；而懶漢式

JavaSE基礎學習筆記及案例(一)IO流與多執行緒(上)

IO流 1. IO流知識點 IO流(字元輸入流FileReader) 位元組輸入流 FileInputStream IO流(字元輸出流FileWriter) 位元組輸出流 FileOutputStream 字元緩衝區輸入流（ BufferedReader） 位元組緩衝區輸入流Bu

JavaSE基礎學習筆記及案例(三)反射

1.反射 1.1反射概述 1.java反射機制是在執行狀態時，對於任意一個類，都可以知道這個類的所有屬性和方法； 動態獲取資訊以及動態呼叫物件的方法稱為java反射機制； 2.反射的三種方式 (1)Object類的getClass()方法，判斷兩個物件是否是同一個位元組碼檔案； (2)靜

JavaWeb學習筆記及案例(二)MVC設計模式

1.MVC三層架構 M:Model>>>模型層：封裝資料Java Bean; V:View>>>檢視層：jsp專注顯示; C:Controller>>>控制層：Servlet接收頁面請求，找模型層處理，然後響應資料出去； **好處：*

【學習筆記】Java-Concurrent-多執行緒容器

BlockingQueue 阻塞佇列 高頻函式:   boolean put() 新增一個元素 沒有空間則一直阻塞等待   boolean add() 新增一個元素 沒有空間則丟擲IllegalStateException異常   boolean off

【學習筆記】Java-Concurrent-多執行緒測試模板

import java.util.concurrent.CountDownLatch; /** * 多執行緒測試模板 * * @author Mairuis * @date 2018/10/11 */ public class ConcurrentTest { public s

Python學習筆記：threading.Condition多執行緒排程

#!/usr/bin/python #coding:utf-8 #引入執行緒和時間模組 import threading,time   #引入執行緒條件變數 cond = threading.Condition() def run():    

多執行緒學習筆記一 ——為什麼使用多執行緒

（1）更多的處理器核心 隨著處理器上的核心數量越來越多，以及超執行緒技術的廣泛運用，現在大多數計算機都 比以往更加擅長平行計算，而處理器效能的提升方式，也從更高的主頻向更多的核心發展。如 何利用好處理器上的多個核心也成了現在的主要問題。 執行緒是大多數作業系統排程的基

Java基礎學習總結（104）——多執行緒、併發、工具類相關的面試題

執行緒的概念 執行緒是程式執行的最小單位，也是作業系統排程和分派CPU的最小單元，是程序中的一個實體，是程序中的實際運作單位。可以在一個程序中啟動多個執行緒來完成不同的任務，這些執行緒共享該程序擁有的資源。 執行緒程序區別 程序是程式的實體，也是執行緒的容器，一個程序可以包含多個執行緒，程序是資源分配的基本單

java 併發程式設計學習筆記（九）多執行緒併發拓展

                                         多執行緒

學習筆記（七）多執行緒開發

相信大家在Java中都已經接觸過執行緒，就是像一條線一樣一次執行相關的操作,特點就是同步的，順序進行的。 但是，Android和Java的執行緒有一點區別在於就是在子執行緒中不能對UI元件進行相關操作，Android中的所有元件的操作要求在主執行緒（UI執行緒

PyQt5學習筆記14----初識pyqt多執行緒操作

首先來看一個例子： # coding=utf-8 __author__ = 'a359680405' from PyQt5.QtCore import * from PyQt5.QtGui import * from PyQt5.QtWidgets import *

Qt學習筆記（十）多執行緒

在一個單處理器上執行時，多執行緒應用程式可能會比實現同樣功能的單執行緒應用程式執行的更慢一些，無法體現出其優勢。但在多處理器上執行時，多執行緒應用程式可以在不同的處理器上同時執行多個執行緒，從而獲得更好的整體效能。 QT通過三種形式提供了對執行緒的支援。它們分別是，一

Dubbo學習筆記8：Dubbo的執行緒模型與執行緒池策略

Dubbo預設的底層網路通訊使用的是Netty，服務提供方NettyServer使用兩級執行緒池，其中 EventLoopGroup(boss) 主要用來接受客戶端的連結請求，並把接受的請求分發給 EventLoopGroup(worker) 來處理，boss和worker執

Java基礎：多執行緒下的單例模式

       單例物件（Singleton）是一種常用的設計模式。在Java應用中，單例物件能保證在一個JVM中，該物件只有一個例項存在。但在多執行緒環境下，就可能會產生問題，並不一定能保證只有一個例項。具體問題描述和解決方法如下。 /* * 多執行緒下

水滴石穿--多執行緒原子操作、threadlocal、volatile、多執行緒下的單例模式

接著上一篇文章，下面看看幾個比較好理解的知識點！！ volatile java關鍵字volatile修飾的變數從字面意義上理解易變的，不穩定的，事實上時告訴編譯器該變數是易變的不要對該變數使用快取等級的優化，每次都從記憶體地址中讀取值。 不過並沒有說明在對volatile修飾的變數進行修

java叢集優化——多執行緒下的單例模式

        在最初學習設計模式時，我為絕佳的設計思想激動不已，在以後的工程中，多次融合設計模式，而在當下的設計中，我們已經覺察出了當初設計模式的高瞻遠矚，但是也有一些不足，需要我們去改進，有人說過

Java多執行緒知識點總結——進階篇（五）之多執行緒下的單例模式

餓漢式 餓漢式多執行緒和單執行緒的程式碼是一樣的，如下： class Single { private static final Single s = new Single(); p

C# 單執行緒和多執行緒下的單例模式的實現

該單例模式是執行緒不安全的，只能在單執行緒下執行，在多執行緒中如果被兩個執行緒同時呼叫Instance屬性時，此時兩個執行緒判斷 if (_instance==null)時都會返回true，就會建立兩個例項。public class Singleton{ /// <

多執行緒下的單例模式

簡介： 保證一個類僅有一個例項，並提供一個該例項的全域性訪問點。《設計模式》GoF 動機 在軟體系統中，經常有這樣一個特殊的類，必須保證它們在系統中只存在一個示例，才能確保它們的邏輯正確性、以及良好的效率。這個應該類設計者的責任，而不是使用者的