溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“Java中的單例模式、堵塞隊列和定時器知識點整理”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java中的單例模式、堵塞隊列和定時器知識點整理”吧！
一、單例模式
餓漢模式
懶漢模式
懶漢模式
二、堵塞隊列
實現BlockingQueue
三、定時器
單例模式是一種設計模式，針對一些特定的場景，研究出對應的解決方案，。有些對象在代碼中只應該有一個實例，單例模式就是強制某個類只能有一個實例。
單例模式的實現，主要依托于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（）方法來操作堵塞隊列
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();
}
}
}感謝各位的閱讀，以上就是“Java中的單例模式、堵塞隊列和定時器知識點整理”的內容了，經過本文的學習后，相信大家對Java中的單例模式、堵塞隊列和定時器知識點整理這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
