国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

并發(fā)編程基礎知識二

CKJOKER / 3062人閱讀

摘要：進入方法線程停止關鍵字雖然擁有多個線程之間的可見性，但是卻不具備原子性關鍵字用于針對多個線程可變的變量操作，但是不能替代關鍵字的同步功能。

volatile關鍵字的作用是變量在多個線程之間可見
volatile的作用是強制線程到主內存（共享內存）里讀取變量，而不是線程工作內存區(qū)里去讀取變量，從而實現(xiàn)了多個線程之間的變量可見，也就是滿足線程安全的可見性。

    private volatile boolean isRunning = true;
    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }
    
    public void run(){
        System.out.println("進入run方法..");
        int i = 0;
        while(isRunning == true){
            //..
        }
        System.out.println("線程停止");
    }

volatile 關鍵字雖然擁有多個線程之間的可見性，但是卻不具備原子性
volatile關鍵字用于針對多個線程可變的變量操作，但是不能替代synchronized關鍵字的同步功能。

atomic類支持原子性操作

    private static AtomicInteger count = new AtomicInteger(0);
    
    
    /**synchronized*/
    public synchronized int multiAdd(){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count.addAndGet(1);
            count.addAndGet(2);
            count.addAndGet(3);
            count.addAndGet(4); //+10
            return count.get();
    }

多個addAndGet在一個方法內是非原子性的，需要加synchronized進行修飾，保證4個addAndGet整體原子性

線程通信
使用wait和notify可以實現(xiàn)線程之間的通信

wait/notify必須配合synchronized 關鍵字使用

wait釋放鎖 notify不釋放鎖

所有的object都可以使用該方法

   // final Object lock = new Object();
    final CountDownLatch countDownLatch = new CountDownLatch(1);
    
    Thread t1 = new Thread(new Runnable() {
    
            public void run() {

                //synchronized (lock) {
                    try {
                        
                        //countDownLatch.countDown();
                        //countDownLatch.awat();
                        //lock.notify();
                        //lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                //}
            }
    }, "t1");

使用wait/nofity的缺點是無法實現(xiàn)實時的通信 推薦使用countDownLatch 來實現(xiàn)實時的交互

使用wait/notify模擬Queue

public class MyQueue {
    
    //1 需要一個承裝元素的集合 
    private LinkedList list = new LinkedList();
    
    //2 需要一個計數(shù)器
    private AtomicInteger count = new AtomicInteger(0);
    
    //3 需要制定上限和下限
    private final int minSize = 0;
    
    private final int maxSize ;
    
    //4 構造方法
    public MyQueue(int size){
        this.maxSize = size;
    }
    
    //5 初始化一個對象 用于加鎖
    private final Object lock = new Object();
    
    
    //put(anObject): 把anObject加到BlockingQueue里,
//如果BlockQueue沒有空間,則調用此方法的線程被阻斷，
//直到BlockingQueue里面有空間再繼續(xù).
    public void put(Object obj){
        synchronized (lock) {
            while(count.get() == this.maxSize){
                try {
                    lock.wait();
                } 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");
        
        t1.start();
        
        
        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");
        
        
        try {
            //代替Thread.sleep(1000);
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t2.start();
        
        
    }
    
    
    
}

TimeUnit是java.util.concurrent包下面的一個類，TimeUnit提供了可讀性更好的線程暫停操作，通常用來替換Thread.sleep()


每次寫一個具有設計意義的小程序 考驗的是分析能力



ThreadLocal：
ThreadLocal 是線程局部變量 是一種多線程間 并發(fā)訪問變量 的解決方案 
ThreadLocal 完全不提供鎖，以空間換時間的方式 為每一個線程提供變量的獨立副本 以保障線程安全


    private static ThreadLocal th = new ThreadLocal();


在并發(fā)量不高 的時候 ，加鎖的性能會更好 
座位一套無鎖的線程安全解決方案 使用ThreadLocal可以減少所競爭



單例模式+多線程
在提高性能的時候 有保證了線程安全


dubble check Instance


public class DubbleSingleton {

    private static DubbleSingleton ds;
    
    public  static DubbleSingleton getDs(){
        if(ds == null){
            try {
                //模擬初始化對象的準備時間...
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (DubbleSingleton.class) {
                if(ds == null){
                    ds = new DubbleSingleton();
                }
            }
        }
        return ds;
    }
}


static inner class


public class Singleton {
    
    private static class InnerSingleton {
        private static Singleton single = new Singleton();
    }
    
    public static Singleton getInstance(){
        return InnerSingleton.single;
    }
    
}
           
               
                                           
                       
                 
            
                     
             
               

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

                 
                   
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/70388.html

               

                      
               
              
              

                
相關文章

                
    
                             
                                                                                                    
  • 
                                                
    
                          
    Java多線程學習（七）并發(fā)編程中一些問題
    
                                                     
    摘要：相比與其他操作系統(tǒng)包括其他類系統(tǒng)有很多的優(yōu)點，其中有一項就是，其上下文切換和模式切換的時間消耗非常少。因為多線程競爭鎖時會引起上下文切換。減少線程的使用。很多編程語言中都有協(xié)程。所以如何避免死鎖的產(chǎn)生，在我們使用并發(fā)編程時至關重要。

系列文章傳送門:
Java多線程學習（一）Java多線程入門
Java多線程學習（二）synchronized關鍵字（1）
java多線程學習（二）syn...
    
                                                   
                          
    
                                
    
                                    dingding199389
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    我的阿里之路+Java面經(jīng)考點
    
                                                     
    摘要：我的是忙碌的一年，從年初備戰(zhàn)實習春招，年三十都在死磕源碼，三月份經(jīng)歷了阿里五次面試，四月順利收到實習。因為我心理很清楚，我的目標是阿里。所以在收到阿里之后的那晚，我重新規(guī)劃了接下來的學習計劃，將我的短期目標更新成拿下阿里轉正。

我的2017是忙碌的一年，從年初備戰(zhàn)實習春招，年三十都在死磕JDK源碼，三月份經(jīng)歷了阿里五次面試，四月順利收到實習offer。然后五月懷著忐忑的心情開始了螞蟻金...
    
                                                   
                          
    
                                
    
                                    姘擱『
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    Java多線程學習（七）并發(fā)編程中一些問題
    
                                                     
    摘要：因為多線程競爭鎖時會引起上下文切換。減少線程的使用。舉個例子如果說服務器的帶寬只有，某個資源的下載速度是，系統(tǒng)啟動個線程下載該資源并不會導致下載速度編程，所以在并發(fā)編程時，需要考慮這些資源的限制。

最近私下做一項目，一bug幾日未解決，總惶恐。一日頓悟，bug不可怕，怕的是項目不存在bug,與其懼怕，何不與其剛正面。
系列文章傳送門:
Java多線程學習（一）Java多線程入門
Jav...
    
                                                   
                          
    
                                
    
                                    yimo
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    史上最全的并發(fā)編程學習
    
                                                     
    一：線程基礎知識
1.并發(fā)編程的基本概念
2. 線程的基本操作
3.線程之間的通信wait和notify
4.join和yield以及sleep詳解
5. synchronized關鍵字講解
6. volatile原理
7. 線程組
8.線程優(yōu)先級
9.守護線程
10.ThreadLocal
二：JDK并發(fā)包
1.jdk并發(fā)工具類
重入鎖
信號量
讀寫鎖
CountDownLatch
cyclic...
    
                                                   
                          
    
                                
    
                                    qylost
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    Python基礎之使用期物處理并發(fā)
    
                                                     
    摘要：本文重點掌握異步編程的相關概念了解期物的概念意義和使用方法了解中的阻塞型函數(shù)釋放的特點。一異步編程相關概念阻塞程序未得到所需計算資源時被掛起的狀態(tài)。

導語：本文章記錄了本人在學習Python基礎之控制流程篇的重點知識及個人心得，打算入門Python的朋友們可以來一起學習并交流。
本文重點：
1、掌握異步編程的相關概念；2、了解期物future的概念、意義和使用方法；3、了解Python...
    
                                                   
                          
    
                                
    
                                    asoren
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
發(fā)表評論

                   
               

              

                

                  
0條評論
   
                
 
                      

              

           
           

              
 
                

                    
                    
CKJOKER

                    
男|高級講師

                    
                    

                          
TA的文章

                          閱讀更多
                    

                      
                


                   
              
  

                  
最新活動
 
           
                             
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
閱讀需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              
              
            

             
        

    







<