Java多線程(單例模式,堵塞隊列,定時器)詳解
一、單例模式
單例模式是一種設計模式，針對一些特定的場景，研究出對應的解決方案，。有些對象在代碼中隻應該有一個實例，單例模式就是強制某個類隻能有一個實例。
單例模式的實現，主要依托於static關鍵字（被static 修飾的成員，靜態成員，把當前的成員變成類屬性而不是實例屬性~）每個類對象隻有一份
單例模式實現有兩種，餓漢模式和懶漢模式
餓漢模式
餓漢模式實現：實例創建出現在“類加載”階段（第一次使用到這個類的時候，就會把這個類.class加載到內存裡），線程安全
public class TestSinger {
//實現單例模式
static class Singleton{
//創建一個成員，保存唯一的一個Singleton實例
private static Singleton instance=new Singleton();
//提供方法獲取實例
public static Singleton getInstance(){
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
//獲取到一個實例 ，隻能通過 getInstance 無法通過new 的方式來創建新的Singleton
Singleton s=Singleton.getInstance();
}
}
懶漢模式
第一次調用getInstance 方法創建實例 （線程不安全）
public class TestSingleton {
//懶漢模式
//創建實例的時機是第一次調用時創建，比餓漢模式更遲
static class Singleton{
private static Singleton instance=null;
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
Singleton s=new Singleton();
}
}
一般來說懶漢模式更好（但不絕對），懶漢模式更高效，但是餓漢模式是線程安全的，懶漢模式是存在線程不安全的狀況，因為懶漢模式有創建線程實例操作，此操作不是原子性，
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
懶漢模式這裡操作先進行讀操作（LOAD）,之後進行比較CMP 之後NEW SAVE（寫入內存），如果這裡有兩個線程執行，會發生搶占式,因為這裡操作不是原子性的，所有會發生創建多個實例的情況，出現瞭BUG，
這裡我們通過加鎖操作來使得操作變為原子性，使得懶漢模式變為線程安全的，可以把鎖加到方法上，這時候是針對CMP,NEW 和 SAVE 操作都進行瞭加鎖，三個操作都是串行的，但是這種效率太低瞭，我們應該把鎖作用范圍更小一點，針對CMP（判斷）和NEW 操作進行加鎖，SAVE 隻是讀操作，並沒有修改，不需要加鎖，提高效率。
public static Singleton getInstance(){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
return instance;
}
但是這樣的代碼，符出的代價太大瞭，因為每次調用都會進行加鎖，我們隻是需要instance未初始化之前，才涉及到線程安全問題，後續已經初始化瞭，就每次要每次都執行加鎖，而是隻是進行判斷就好瞭，所以又修改瞭代碼，改為雙if判斷
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
但是這樣寫還是會有瑕疵，因為在多線程的情況下，可能多個線程進行讀操作，由於編譯器優化，可能在寄存器讀取，而這時候執行操作還沒有執行完，還是null的狀態，所以我們也要在獲取實例時候加上鎖
懶漢模式
保證線程安全：
1.加鎖，把if判斷和new操作加鎖
2.雙重if循環
3.volatile 關鍵字
//懶漢模式
static class Singleton{
volatile private static Singleton instance=null;
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
Singleton s=new Singleton();
}
針對單例模式的線程安全要點：
1）加鎖（在合適的位置加鎖，CMP（判斷）和NEW（創建）時加鎖，同時加鎖的范圍也不能太大，避免降低效率）
2）雙重 判斷（保證需要加鎖時候才加鎖，一旦初始化完畢瞭，就不用創建實例，都為讀操作，就沒必要加鎖瞭）
3）volatile 保證外層 if 讀操作，讀到的數值都是最新的，不會出現一個正在創建實例，而讀取時是NULL 進入IF判斷的情況
二、堵塞隊列
堵塞隊列是什麼？ 一種線程安全的隊列，
1.首先堵塞隊列是線程安全的（內部實現瞭加鎖控制），
2.當隊列滿的時候，此時就會堵塞，一直到堵塞隊列不滿的情況下才會完成插入，當隊列為空時，從隊列中取元素時，也會發生堵塞。
堵塞隊列的作用：
幫助我們完成“生產者消費者模型”，作用於服務器開發
生產者和消費者模型通過某種交易場所（某數據結構）來進行交互 ，堵塞隊列就是其中的一種數據結構，能夠很好的協調生產者和消費者之間的關系，
實際案例（服務器請求）：
一個服務器，同一時刻可能收到很多請求，但是服務器處理能力是有限的，如果同一時間服務器收到的請求太多瞭，服務器可能就掛瞭…，針對這樣的場景，使用生產者和消費者模式來進行“削峰”，削弱請求峰值對服務器的沖擊力，如果服務器面對請求太多瞭，實際上先把請求放入堵塞隊列中，應用程序按照固定的結構從堵塞隊列中取出，這些請求沖擊的是堵塞隊列本身，請求在這裡耗著，不會消耗太多的CPU資源，緩解服務器壓力
消息隊列，是堵塞隊列的上級
1.消息隊列中數據是有類型的（topic），按照topic進行分類，把相同topic的數據放到不同的隊伍中，分別進行排隊，一個消息隊列，可以支撐多個業務的多組數據~~
2.消息隊列往往是單獨的服務器/服務器集群，通過網絡通信的方式，進行生產者和消費者模型
3.還支持持久化存儲（數據存儲在磁盤上）
4.消費的時候支持多種消費模式
a)指定位置消費（不一定隻是取出隊首元素）
b)鏡像模式消費（一個數據可以被取多次，不是取一次直接刪除）
實現堵塞隊列：
public static void main(String[] args) {
//BlockingDeque 本身是一個interface 不能去new
BlockingDeque<String> blockingDeque=new LinkedBlockingDeque<>();
try {
//put 和 take 都有堵塞功能
//堵塞隊列也有普通方法但是沒有堵塞功能。
blockingDeque.put("hello");
String elem=blockingDeque.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
實現一個生產者和消費者模型
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
public class Demo2 {
//實現生產者和消費者模型
public static void main(String[] args) {
BlockingDeque<String> queue=new LinkedBlockingDeque();
//創建生產者線程
Thread producer=new Thread(){
@Override
public void run() {
for(int i=0;i<10000;i++){
try {
System.out.println("producer 生成 str"+i);
queue.put("str "+i);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
//消費者線程
Thread customer=new Thread(){
@Override
public void run() {
while(true){
try {
String elem=queue.take();
System.out.println("customer 獲取到" + elem);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
try {
producer.join();
customer.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
這裡實現的是生產者每一秒生成一個，生產者比消費者慢
可以借助堵塞隊列的最大長度來設置一個生產者比消費者快的情況，將最大長度設為10，使用sleep 一秒消費一個，但是一直在生產，這樣就是生產者大於消費者，主要使用put（）和take（）方法來操作堵塞隊列
實現BlockingQueue
1）首先要實現一個隊列，可以用鏈表或者數組實現隊列，這裡使用數組實現一個隊列（環形隊列），定義兩個變量head,tail來標記數組頭部和尾部，插入元素時，插在tail位置，tail++,出隊列時取出head位置元素，head++，定義一個變量來標記長度，如果長度等於數組長度，則要回到數組的頭部，來實現環形數組
public class ThreadDemo1 {
//自己實現堵塞隊列，先通過數組實現普通隊列
static class BlockingQueue{
private int[] array=new int[1000];
private int head=0;//記錄頭部
private int tail=0;//記錄尾部
private int size=0;
//實現入隊列
public void put(int value){
if(size==array.length){
System.out.println("隊列滿瞭，不能插入");
return ;
}
array[tail]=value;
tail++;
//解決環形數組
if(tail>=array.length){
tail=0;
}
size++;
}
//實現出隊列
public Integer take(){
if(size==0){
return null;
}
int ret=array[head];
head++;
if(head>=array.length){
head=0;
}
size--;
return ret;
}
}
}
2.為瞭保證線程安全給隊列進行加鎖操作，並且實現堵塞隊列
註意實現堵塞隊列，此時隊列是滿的，多個線程實現都是要等待，當一個線程取走一個元素，就會通知其他線程隊列不滿，多個線程就要競爭鎖，所以獲取到鎖操作後，還是要判斷隊列是否滿，可能這個線程沒有競爭到鎖，所以要用while()來進行等待
static class BlockingQueue{
private int[] array=new int[1000];
private int head=0;//記錄頭部
private int tail=0;//記錄尾部
//記錄隊列中元素長度
private int size=0;
//引入一個鎖對象
private Object locker=new Object();
//實現入隊列
public void put(int value) throws InterruptedException {
synchronized (locker){
while(size==array.length){
locker.wait();
}
array[tail]=value;
tail++;
//解決環形數組
if(tail>=array.length){
tail=0;
}
size++;
locker.notifyAll();
}
}
//實現出隊列
public Integer take() throws InterruptedException {
int ret=0;
synchronized (locker){
while (size==0){
locker.wait();
}
ret=array[head];
head++;
if(head>=array.length){
head=0;
}
size--;
locker.notifyAll();//喚醒操作，提醒等待元素，隊列有位置瞭
}
return ret;
}
}
創建一個生產者消費者模型來檢驗自己實現的堵塞隊列是否成功
public static void main(String[] args) throws InterruptedException {
BlockingQueue queue=new BlockingQueue();
Thread producer=new Thread(){
@Override
public void run() {
for(int i=0;i<10000;i++){
try {
System.out.println("生產瞭元素："+ i);
queue.put(i);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
Thread customer=new Thread(){
@Override
public void run() {
try {
while(true){
int ret=queue.take();
System.out.println("消費瞭元素 "+ ret);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
customer.start();
producer.join();
customer.join();
}
實現瞭一個簡單的堵塞隊列
三、定時器
定時器就是鬧鐘，給定時器設定一個任務，約定某個任務XXX時間後執行
目的：讓某個任務在某個時間點執行，不是立刻執行
使用Timer 提供的核心接口 schedule 指定一個任務交給定時器，再一定的時間之後執行這個任務
實現定時器
1）Timer 類中要包含一個Task類，每個Task類就表示一個具體的任務，Task裡面包含一個時間戳（啥時候執行這個任務），還包含瞭一個Runnable 實例（用來表示具體任務是啥）
2）Timer裡面通過一個帶優先級的堵塞隊列，來組織若幹個task，根據時間先後來排優先級，快帶時間的任務優先級更高
3）Timer 中還需要一個專門的線程，讓這個線程不停掃描隊首元素，看看隊首元素是不是可以執行瞭，如果可以執行瞭，就執行這個任務，如果不能執行，就繼續在隊列中等待。
實現定時器:
import java.util.concurrent.PriorityBlockingQueue;
public class ThreadDemo2 {
//實現一個簡單的定時器 task要放到一個優先隊列中，但是優先隊列中需要進行比較排序
static class Task implements Comparable<Task>{
//啥時候去執行
private long time;
//執行什麼
private Runnable command;
//一般去設定定時器的時候，傳入的時間，一般都是時間間隔
public Task(Runnable command,long time){
this.command=command;
//記錄絕對時間
this.time=System.currentTimeMillis()+time;
}
public void run(){
command.run();
}
@Override
public int compareTo(Task o) {
//時間較小的排在前面
return (int)(this.time-o.time);
}
}
static class Timer{
//創建一個帶優先級的堵塞隊列
private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();
//使用這個對象來實現線程之間的協調任務
private Object mailBox=new Object();
//schedule 方法的功能就是把一個Task 放到Timer中
public void schedule(Runnable command,long after){
Task task=new Task(command,after);
queue.put(task);
//當worker 線程中包含wait 機制的時候，在安排任務的時候就需要顯式的喚醒一下瞭
synchronized (mailBox){
mailBox.notify();
}
}
public Timer(){
//創建一個線程，讓這個線程去掃描隊列的隊首元素
Thread worker=new Thread(){
@Override
public void run() {
while (true){
//取出隊首元素，判定一下這個元素能不能執行
try {
Task task=queue.take();
long currentTime=System.currentTimeMillis();
if(currentTime>=task.time){
//時間到瞭執行任務
task.run();
}else{
//時間沒到，繼續等待
queue.put(task);
synchronized (mailBox){
mailBox.wait(task.time-currentTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
worker.start();
}
}
}
總結
本篇文章就到這裡瞭，希望能給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！