亚洲中字慕日产2020,大陆极品少妇内射AAAAAA,无码av大香线蕉伊人久久,久久精品国产亚洲av麻豆网站

資訊專欄INFORMATION COLUMN

初識Queue隊列

Miracle_lihb / 616人閱讀

摘要：架構(gòu)師入門筆記三初識隊列和模擬基礎(chǔ)知識線程通信概念線程是操作系統(tǒng)中獨立的個體，但這些個體如果不經(jīng)過特殊的處理，就不能成為一個整體，線程之間的通信就成為整體的必用方法之一。它是一個基于鏈接節(jié)點的無界限線程安全隊列。

架構(gòu)師入門筆記三 初識Queue隊列 wait和notify模擬Queue wait/notify 基礎(chǔ)知識

線程通信概念：線程是操作系統(tǒng)中獨立的個體，但這些個體如果不經(jīng)過特殊的處理，就不能成為一個整體，線程之間的通信就成為整體的必用方法之一。
使用 wait/notify 方法注意點：
1）wait 和 notify 必須要配合 synchronized 關(guān)鍵字使用
2）wait方法是釋放鎖的， notify方法不釋放鎖。

wait/notify 模擬BlockingQueue

BlockingQueue：是一個隊列，并且支持阻塞的機制，阻塞的放入和得到數(shù)據(jù)。我們要實現(xiàn) LinkedBlockingQueue 下面兩個簡單的方法put 和 take
put(an object)：把一個object 加到BlockingQueue里，如果BlockingQueue沒有空間，則調(diào)用此方法的線程會被阻斷，直到BlockingQueue里面有空間再繼續(xù)。
take：取走BlockingQueue里排在首位的對象，若BlockingQueue為空，阻斷進入等待狀直到BlockingQueue有新數(shù)據(jù)被加入。

import java.util.LinkedList;  
import java.util.concurrent.TimeUnit;  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class MyQueue {  
      
    //1 需要一個承裝元素的集合   
    private LinkedList list = new LinkedList();  
    //2 需要一個計數(shù)器 AtomicInteger （原子性）  
    private AtomicInteger count = new AtomicInteger(0);  
    //3 需要制定上限和下限  
    private final int minSize = 0;  
    private final int maxSize ;  
      
    //4 構(gòu)造方法  
    public MyQueue(int size){  
        this.maxSize = size;  
    }  
      
    //5 初始化一個對象 用于加鎖  
    private final Object lock = new Object();  
      
    //put(anObject): 把anObject加到BlockingQueue里,如果BlockQueue沒有空間,則調(diào)用此方法的線程被阻斷，直到BlockingQueue里面有空間再繼續(xù).  
    public void put(Object obj){  
        synchronized (lock) {  
            while(count.get() == this.maxSize){  
                try {  
                    lock.wait();  // 當Queue沒有空間時，線程被阻塞  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            //1 加入元素  
            list.add(obj);  
            //2 計數(shù)器累加  
            count.incrementAndGet();  
            //3 新增元素后，通知另外一個線程（喚醒），隊列多了一個元素，可以做移除操作了。  
            lock.notify();  
            System.out.println("新加入的元素為:" + obj);  
        }  
    }  
      
    //take: 取走BlockingQueue里排在首位的對象,若BlockingQueue為空,阻斷進入等待狀態(tài)直到BlockingQueue有新的數(shù)據(jù)被加入.  
    public Object take(){  
        Object ret = null;  
        synchronized (lock) {  
            while(count.get() == this.minSize){  
                try {  
                    lock.wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            //1 做移除元素操作  
            ret = list.removeFirst();  
            //2 計數(shù)器遞減  
            count.decrementAndGet();  
            //3 移除元素后，喚醒另外一個線程，隊列少元素了，可以再添加操作了  
            lock.notify();  
        }  
        return ret;  
    }  
      
    public int getSize(){  
        return this.count.get();  
    }  
      
    public static void main(String[] args) {  
        final MyQueue mq = new MyQueue(5);  
        mq.put("a");  
        mq.put("b");  
        mq.put("c");  
        mq.put("d");  
        mq.put("e");  
        System.out.println("當前容器的長度:" + mq.getSize());  
        Thread t1 = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                mq.put("f");  
                mq.put("g");  
            }  
        },"t1");  
        Thread t2 = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                Object o1 = mq.take();  
                System.out.println("移除的元素為:" + o1);  
                Object o2 = mq.take();  
                System.out.println("移除的元素為:" + o2);  
            }  
        },"t2");  
        t1.start();  
        try {  
            TimeUnit.SECONDS.sleep(2);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        t2.start();  
    }  
      
}  

從打印的信息可以看出，當t2 線程移除數(shù)據(jù)后，t1線程才開始加入數(shù)據(jù)


并發(fā)Queue
Queue 簡介

Queue的主要實現(xiàn)如下圖所示。
圖片描述


Queue主要分兩類，一類是高性能隊列 ConcurrentLinkedQueue； 一類是阻塞隊列 BlockingQueue

ConcurrentLinkedQueue接口

ConcurrentLinkedQueue：是一個適合高并發(fā)場景下的隊列，通過無鎖的方式，實現(xiàn)了高并發(fā)狀態(tài)下的高性能。通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一個基于鏈接節(jié)點的無界限線程安全隊列。該隊列的元素遵循先進先出的原則。頭是最先加入的，尾是最后加入的。該隊列不允許null元素。
ConcurrentLinkedQueue 重要方法：
add() 和 offer() 都是加入元素，該隊列中無區(qū)別
poll() 和 peek() 都是取頭元素節(jié)點，區(qū)別在于前者會刪除元素，后者不會


import java.util.concurrent.ConcurrentLinkedQueue;  
  
public class MyConcurrentLinkedQueue {  
  
    public static void main(String[] args) throws Exception {  
          
        //高性能無阻塞無界隊列：ConcurrentLinkedQueue  
        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();  
        q.offer("a");  
        q.offer("b");  
        q.offer("c");  
        q.offer("d");  
        q.add("e");  
          
        System.out.println(q.poll());   // 打印結(jié)果：a （從頭部取出元素，并從隊列里刪除）  
        System.out.println(q.size());   // 打印結(jié)果：4 （執(zhí)行poll 后 元素減少一個）  
        System.out.println(q.peek());   // 打印結(jié)果：b （a 被移除了，首元素就是b）  
        System.out.println(q.size());   // 打印結(jié)果：4 （peek 不移除元素）  
          
    }  
}  

BlockingQueue接口

ArrayBlockingQueue： 基于數(shù)組的阻塞隊列實現(xiàn)。在內(nèi)部，維護了一個定長數(shù)組，以便緩存隊列中的數(shù)據(jù)對象。其內(nèi)部沒有實現(xiàn)讀寫分離，也就意味著生產(chǎn)和消費不能完全并行。長度是需要定義的，可以指定先進先出或者先進后出，是一個有界隊列。


import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.TimeUnit;  
  
public class MyArrayBlockingQueue {  
  
    public static void main(String[] args) throws Exception {  
        ArrayBlockingQueue array = new ArrayBlockingQueue(5); // 可以嘗試 隊列長度由3改到5  
        array.offer("offer 方法 插入數(shù)據(jù)成功返回true 否則返回false");  
        array.offer("3秒后插入數(shù)據(jù)", 3, TimeUnit.SECONDS);  
        array.put("put 方法 若超出長度就會阻塞等待");  
        array.add("add 方法 在超出長度時會提示錯誤信息 java.lang.IllegalStateException"); //  java.lang.IllegalStateException: Queue full  
        System.out.println(array.offer("true or false", 3, TimeUnit.SECONDS));  
        System.out.println(array);  
    }  
}  


LinkedBlockingQueue：基于列表的阻塞隊列。同ArrayBlockingQueue類似，其內(nèi)部維護了一個數(shù)據(jù)緩沖隊列（該隊列由一個鏈表構(gòu)成）。它之所以能夠高效的處理并發(fā)數(shù)據(jù)，是因為其內(nèi)部實現(xiàn)采用分離鎖（讀寫分離兩個鎖），從而實現(xiàn)生產(chǎn)者和消費者操作的完全并行運行。是一個無界隊列
用法和 ArrayBlockingQueue 差不多 。區(qū)別在于，LinkedBlockingQueue是無界隊列，初始化的時候，可以設(shè)置一個長度，也可以不設(shè)置。
SynchronousQueue：一種沒有緩沖的隊列，生存者生產(chǎn)的數(shù)據(jù)直接會被消費者獲取并消費。


以上三個隊列，用于什么場景呢？舉個坐地鐵例子： 
在人少的時候，直接刷卡進站，無需等待，這用SynchronousQueue。 
上班高峰期，人很多，刷卡的時候需要排隊，這用LinkedBlockingQueue無界隊列。
放假高峰期，人滿人患，這時候就要用有界隊列ArrayBlockingQueue。如果采用LinkedBlockingQueue 無界隊列的話，進來的人太多會影響地鐵站正常工作了，所以人太多就不讓進，等下次。


PriorityBlockingQueue：基于優(yōu)先級的阻塞隊列（優(yōu)先級的判斷通過構(gòu)造函數(shù)傳入的Compator對象來決定，也就是說傳入隊列的對象必須實現(xiàn)Comparable接口），在實現(xiàn)PriorityBlockingQueue時，內(nèi)部控制線程同步的鎖采用的是公平鎖，是一個無界隊列。
傳入隊列的對象：Task


public class Task implements Comparable{  
      
    private int id ;  
    private String name;  
      
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
    @Override  
    public int compareTo(Task task) {  
        return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);    
    }  
      
    public String toString(){  
        return this.id + "," + this.name;  
    }  
      
}  


PriorityBlockingQueue 排序：


import java.util.concurrent.PriorityBlockingQueue;  
  
public class MyPriorityBlockingQueue {  
      
    public static void main(String[] args) throws Exception{  
          
        PriorityBlockingQueue q = new PriorityBlockingQueue();  
          
        // 由大到小的設(shè)置  
        Task t1 = new Task();  
        t1.setId(1);  
        t1.setName("id為1");  
        Task t2 = new Task();  
        t2.setId(4);  
        t2.setName("id為4");  
        Task t3 = new Task();  
        t3.setId(9);  
        t3.setName("id為9");  
        Task t4 = new Task();  
        t4.setId(16);  
        t4.setName("id為16");  
        Task t5 = new Task();  
        t5.setId(5);  
        t5.setName("id為5");  
          
        // 故意打亂順序進入隊列  
        q.add(t3);  
        q.add(t4);  
        q.add(t1);  
        q.add(t2);  
        q.add(t5);  
          
        System.out.println("初始隊列容器：" + q);  
        System.out.println("第一個元素：" + q.take()); // 執(zhí)行take后排序（取值后排序輸出）  
        System.out.println("執(zhí)行take方法后容器：" + q);  
          
    }  
}  


DelayQueue：帶有延遲時間的Queue，其中的元素只有指定的延遲時間到了，才能夠從隊列中獲取到該元素，DelayQueue中的元素必須實現(xiàn)Delayed接口，DelayQueue是一個沒有大小限制的隊列，應(yīng)用場景很多，比如對緩存超時的數(shù)據(jù)進行移除，任務(wù)超時處理，空閑連接的關(guān)閉等等
摘錄網(wǎng)上代碼，一個網(wǎng)吧上網(wǎng)的案例：


import java.util.concurrent.Delayed;  
import java.util.concurrent.TimeUnit;  
  
public class Wangmin implements Delayed {    
      
    private String name;    
    //身份證    
    private String id;    
    //截止時間    
    private long endTime;    
    //定義時間工具類  
    private TimeUnit timeUnit = TimeUnit.SECONDS;  
        
    public Wangmin(String name,String id,long endTime){    
        this.name=name;    
        this.id=id;    
        this.endTime = endTime;    
    }    
        
    public String getName(){    
        return this.name;    
    }    
        
    public String getId(){    
        return this.id;    
    }    
        
    /**  
     * 用來判斷是否到了截止時間  
     */    
    @Override    
    public long getDelay(TimeUnit unit) {   
        //return unit.convert(endTime, TimeUnit.MILLISECONDS) - unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);  
        return endTime - System.currentTimeMillis();  
    }    
    
    /**  
     * 相互批較排序用  
     */    
    @Override    
    public int compareTo(Delayed delayed) {    
        Wangmin w = (Wangmin)delayed;    
        return this.getDelay(this.timeUnit) - w.getDelay(this.timeUnit) > 0 ? 1:0;    
    }    
}    


import java.util.concurrent.DelayQueue;  
  
public class WangBa implements Runnable {    
      
    private DelayQueue queue = new DelayQueue();    
    public boolean yinye =true;    
        
    public void shangji(String name,String id,int money){    
        Wangmin man = new Wangmin(name, id, 1000 * money + System.currentTimeMillis());    
        System.out.println("網(wǎng)名"+man.getName()+" 身份證"+man.getId()+"交錢"+money+"塊,開始上機...");    
        this.queue.add(man);    
    }    
        
    public void xiaji(Wangmin man){    
        System.out.println("網(wǎng)名"+man.getName()+" 身份證"+man.getId()+"時間到下機...");    
    }    
    
    @Override    
    public void run() {    
        while(yinye){    
            try {    
                Wangmin man = queue.take();    
                xiaji(man);    
            } catch (InterruptedException e) {    
                e.printStackTrace();    
            }    
        }    
    }    
        
    public static void main(String args[]){    
        try{    
            System.out.println("網(wǎng)吧開始營業(yè)");    
            WangBa siyu = new WangBa();    
            Thread shangwang = new Thread(siyu);    
            shangwang.start();    
                
            siyu.shangji("路人甲", "123", 1);    
            siyu.shangji("路人乙", "234", 10);    
            siyu.shangji("路人丙", "345", 5);    
        }    
        catch(Exception e){    
            e.printStackTrace();  
        }    
    
    }    
}    
           
               
                                           
                       
                 
            
                     
             
               

                   
 文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

                 
                   
轉(zhuǎn)載請注明本文地址：http://www.ezyhdfw.cn/yun/70524.html

               

                      
               
              
              

                
相關(guān)文章

                
    
                             
                                                                                                    
  • 
                                                
    
                          
    初識JavaScript EventLoop
    
                                                     
    摘要：指的是計算機系統(tǒng)的一種運行機制。環(huán)境中的執(zhí)行順序是隨機的這一次，徹底弄懂執(zhí)行機制的規(guī)范和實現(xiàn)

showImg(https://segmentfault.com/img/remote/1460000012913034?w=800&h=421);
Event Loop指的是計算機系統(tǒng)的一種運行機制。JavaScript采用此機制解決單線程引發(fā)相關(guān)問題
在瀏覽器中的web應(yīng)用會涉及到.Jav...
    
                                                   
                          
    
                                
    
                                    ZHAO_
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    消息中間件——RabbitMQ（三）理解RabbitMQ核心概念和AMQP協(xié)議！
    
                                                     
    摘要：后續(xù)介紹交換機，生產(chǎn)者直接將消息投遞到中。消息，服務(wù)器和應(yīng)用程序之間傳送的數(shù)據(jù)，由和組成。也稱為消息隊列，保存消息并將它們轉(zhuǎn)發(fā)給消費者。主要是應(yīng)為和有一個綁定的關(guān)系。

showImg(https://img-blog.csdnimg.cn/20190509221741422.gif);
showImg(https://img-blog.csdnimg.cn/20190731191914...
    
                                                   
                          
    
                                
    
                                    sihai
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
發(fā)表評論

                   
               

              

                

                  
0條評論
   
                
 
                      

              

           
           

              
 
                

                    
                    
Miracle_lihb

                    
男|高級講師

                    
                    

                          
TA的文章

                          閱讀更多
                    

                      
                


                   
              
  

                  
最新活動
 
           
                             
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
閱讀需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              
              
            

             
        

    








<