2. 程式人生 > >黑馬程式設計師多執行緒視訊總結

黑馬程式設計師多執行緒視訊總結

阿新 • • 發佈：2019-01-03

執行緒池的工作模型主要兩部分組成，一部分是執行Runnable的Thread物件，另一部分就是阻塞佇列。

由執行緒池建立的Thread物件其內部的run方法會通過阻塞佇列的take方法獲取一個Runnable物件，然後執行這個Runnable物件的run方法（即，在Thread的run方法中呼叫Runnable物件的run方法）。當Runnable物件的run方法執行完畢以後，Thread中的run方法又迴圈的從阻塞佇列中獲取下一個Runnable物件繼續執行。這樣就實現了Thread物件的重複利用，也就減少了建立執行緒和銷燬執行緒所消耗的資源。

當需要向執行緒池提交任務時會呼叫阻塞佇列的offer方法向佇列的尾部新增任務。提交的任務實際上就是是Runnable物件或Callable物件。

1.執行緒範圍共享變數

public class ThreadScopeShareData {

private static int data = 0;
private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
public static void main(String[] args) {
    for(int i=0;i<2;i++){
        new Thread(new Runnable(){
            @Override
            public void run() {
                int data = new Random().nextInt();
                System.out.println(Thread.currentThread().getName() 
                        + " has put data :" + data);
                //threadData.put(Thread.currentThread(), data);
                threadData.set(data);//這樣寫即可
                new A().get();
                new B().get();
            }
        }).start();
    }
}

static class A{
    public void get(){
        int data = threadData.get(Thread.currentThread());
        System.out.println("A from " + Thread.currentThread().getName() 
                + " get data :" + data);
    }
}

static class B{
    public void get(){
        int data = threadData.get(Thread.currentThread());          
        System.out.println("B from " + Thread.currentThread().getName() 
                + " get data :" + data);
    }       
}

}

2.TreadLocal實現執行緒範圍共享變數

public class ThreadLocalTest {
//一個TreadLocal只能代表一個變數，要是有多個數據需要線上程範圍共享就要有多個TreadLocal，或者弄成類
private static ThreadLocal x = new ThreadLocal();
private static ThreadLocal myThreadScopeData = new ThreadLocal();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
@Override
public void run() {
int data = new Random().nextInt();
System.out.println(Thread.currentThread().getName()
+ ” has put data :” + data);
x.set(data);

                /*MyThreadScopeData myData = new MyThreadScopeData();
                myData.setName("name" + data);
                myData.setAge(data);
                myThreadScopeData.set(myData);*/

                MyThreadScopeData.getThreadInstance().setName("name" + data);
                MyThreadScopeData.getThreadInstance().setAge(data);
                new A().get();
                new B().get();
            }
        }).start();
    }
}

static class A{
    public void get(){
        int data = x.get();
        System.out.println("A from " + Thread.currentThread().getName() 
                + " get data :" + data);

        /*MyThreadScopeData myData = myThreadScopeData.get();;
        System.out.println("A from " + Thread.currentThread().getName() 
                + " getMyData: " + myData.getName() + "," +
                myData.getAge());*/

        MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
        System.out.println("A from " + Thread.currentThread().getName() 
                + " getMyData: " + myData.getName() + "," +
                myData.getAge());
    }
}

static class B{
    public void get(){
        int data = x.get();         
        System.out.println("B from " + Thread.currentThread().getName() 
                + " get data :" + data);
        //得到當前執行緒的物件
        MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
        System.out.println("B from " + Thread.currentThread().getName() 
                + " getMyData: " + myData.getName() + "," +
                myData.getAge());           
    }       
}

}

class MyThreadScopeData{
//按照單例相似的去寫優雅的方式
private MyThreadScopeData(){}
//不用synchronized因為一個執行緒對應修改get set自己的變數
public static /synchronized/ MyThreadScopeData getThreadInstance(){
MyThreadScopeData instance = map.get();
if(instance == null){
instance = new MyThreadScopeData();
map.set(instance);
}
return instance;
}
//private static MyThreadScopeData instance = null;//new MyThreadScopeData();
private static ThreadLocal map = new ThreadLocal();

private String name;
private int age;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}

}

3.多執行緒訪問共享物件和資料的方法
如果每個執行緒執行的程式碼相同，可用同一個Runnable物件，Runnable中由共享資料（例如賣票）
如果每個執行緒執行的程式碼不同，可將共享資料封裝在另一個物件中，然後將這個物件逐一傳遞給各Runnable

public class MultiThreadShareData {

private static ShareData1 data1 = new ShareData1();

public static void main(String[] args) {
    ShareData1 data2 = new ShareData1();
    new Thread(new MyRunnable1(data2)).start();
    new Thread(new MyRunnable2(data2)).start();

    final ShareData1 data1 = new ShareData1();
    new Thread(new Runnable(){
        @Ov  erride
        public void run() {
            data1.decrement();

        }
    }).start();
    new Thread(new Runnable(){
        @Override
        public void run() {
            data1.increment();

        }
    }).start();

}

}

class MyRunnable1 implements Runnable{
    private ShareData1 data1;
    public MyRunnable1(ShareData1 data1){
        this.data1 = data1;
    }
    public void run() {
        data1.decrement();

    }
}

class MyRunnable2 implements Runnable{
    private ShareData1 data1;
    public MyRunnable2(ShareData1 data1){
        this.data1 = data1;
    }
    public void run() {
        data1.increment();
    }
}

class ShareData1 /*implements Runnable*/{

/* private int count = 100;
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
count–;
}
}*/

    private int j = 0;
    public synchronized void increment(){
        j++;
    }

    public synchronized void decrement(){
        j--;
    }
}

java5之後：
4.原子類：AtomicInteger AtomicIntegerArray 。。。應用於多執行緒共享的資料

5.tomcat伺服器中
new Thread(){
while(池子中還有執行緒需要接待）{
和執行緒聊一會；
}
}.start();

執行緒池
public class ThreadPoolTest {

public static void main(String[] args) {
    //ExecutorService threadPool = Executors.newFixedThreadPool(3); 固定數目的執行緒池，3個3個搶佔資源
    //ExecutorService threadPool = Executors.newCachedThreadPool(); 數目動態變化的執行緒池，來多少執行緒池多大
    ExecutorService threadPool = Executors.newSingleThreadExecutor();單一執行緒池，如何實現執行緒死了後重新啟動，當一個執行緒死了後，會馬上找一個替補的執行緒
    for(int i=1;i<=10;i++){
        final int task = i;
        threadPool.execute(new Runnable(){
            @Override
            public void run() {
                for(int j=1;j<=10;j++){
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " is looping of " + j + " for  task of " + task);
                }
            }
        });
    }
    System.out.println("all of 10 tasks have committed! ");
    //threadPool.shutdownNow();

    //定時器
    Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
            new Runnable(){
                @Override
            public void run() {
                System.out.println("bombing!");

            }},
            6,
            2,
            TimeUnit.SECONDS);
}

}

6.
public class CallableAndFuture {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future future =
threadPool.submit( ——提交一個返回值
new Callable() {
public String call() throws Exception {
Thread.sleep(2000);
return “hello”;
};
}
);
System.out.println(“等待結果”);
try {
System.out.println(“拿到結果：” + future.get());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

    //CompletionService用於提交一組Callable任務，take方法返回已完成的Callable任務對應的furtuer物件
    ExecutorService threadPool2 =  Executors.newFixedThreadPool(10);
    CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);
    //提交10個任務
    for(int i=1;i<=10;i++){
        final int seq = i;
        completionService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(new Random().nextInt(5000));
                return seq;
            }
        });
    }
    //拿到10個結果
    for(int i=0;i<10;i++){
        try {
            System.out.println(
                    completionService.take().get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

}

7.讀寫鎖：讀寫互斥，寫寫互斥，讀讀沒事
鎖比synchronized更加面向物件，必須要再結尾finnal中釋放鎖

public class ReadWriteLockTest {
public static void main(String[] args) {
final Queue3 q3 = new Queue3();
for(int i=0;i<3;i++)
{
new Thread(){
public void run(){
while(true){
q3.get();
}
}

        }.start();

        new Thread(){
            public void run(){
                while(true){
                    q3.put(new Random().nextInt(10000));
                }
            }           

        }.start();
    }

}

}

class Queue3{
private Object data = null;//共享資料，只能有一個執行緒能寫該資料，但可以有多個執行緒同時讀該資料。
ReadWriteLock rwl = new ReentrantReadWriteLock();
public void get(){
rwl.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + ” be ready to read data!”);
Thread.sleep((long)(Math.random()*1000));
System.out.println(Thread.currentThread().getName() + “have read data :” + data);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock();
}
}

public void put(Object data){

    rwl.writeLock().lock();
    try {
        System.out.println(Thread.currentThread().getName() + " be ready to write data!");                  
        Thread.sleep((long)(Math.random()*1000));
        this.data = data;       
        System.out.println(Thread.currentThread().getName() + " have write data: " + data);                 
    } catch (InterruptedException e) {
        e.printStackTrace();
    }finally{
        rwl.writeLock().unlock();
    }


}

}

8.模擬快取
這樣寫讀寫效率高
public class CacheDemo {
//內部定義一個map
private Map

相關推薦

黑馬程式設計師多執行緒視訊總結

執行緒池的工作模型主要兩部分組成，一部分是執行Runnable的Thread物件，另一部分就是阻塞佇列。 由執行緒池建立的Thread物件其內部的run方法會通過阻塞佇列的take方法獲取一個Runnable物件，然後執行這個Runnable物件的run方法（

黑馬程式設計師——多執行緒之Runnable與Thread

------Java培訓、Android培訓、java學習型部落格、期待與您交流！ ------- 一、程序和執行緒的基本概念和相互之間的關係。        所謂程序，是一個具有獨立功能的程式關於某個資料集合的一次執行活動。它可以申請和擁有系統資源，是一個動態的概念，是一

黑馬程式設計師 關於執行緒的瞭解二

----------android培訓、java培訓、java學習型技術部落格、期待與您交流！---------- 互斥與同步 引子 由於多執行緒共享同一資源（臨界資源），使得多執行緒程式結果會有不確定性。 怎麼解決不確定性呢？以下兩種方式可以部分控制不確定性：

Linux多執行緒學習總結

原文:https://www.cnblogs.com/luoxn28/p/6087649.html Linux多執行緒學習總結 　　執行緒是程式中完成一個獨立任務的完整執行序列，即一個可排程的實體；程序相當於執行中程式的一種抽象。根據執行環境的排程者的身份，執行緒可分為核心執行緒和使用者執行

為什麼當前大多數應用程式是多執行緒的，為什麼要使用支援多執行緒的庫

原文 http://www.nynaeve.net/?p=198         大部分的Win32 程式在執行的時候，其程序中至少有一段時間是超過一個執行緒的，儘管有時程式沒有明確的建立一個執行緒。這是因

多執行緒學習總結（二）

一、多執行緒帶來的問題 （一）活躍性問題 死鎖：兩個執行緒相互等待對方釋放資源 飢餓： 多執行緒併發時優先順序低的執行緒永遠得不到執行；執行緒被永久阻塞在一個等待進入同步塊的狀態；等待的執行緒永遠不被喚醒 活鎖：活鎖指的是任務或者執行者沒有被阻塞，由於某些條件沒有滿足，導致

多執行緒學習總結——鎖

何為同步？JVM規範規定JVM基於進入和退出Monitor物件來實現方法同步和程式碼塊同步，但兩者的實現細節不一樣。程式碼塊同步是使用monitorenter和monitorexit指令實現，而方法同步是使用另外一種方式實現的，細節在JVM規範裡並沒有詳細說明，但是方法的同步同樣可以使用這兩個指令來

多執行緒學習總結（一）

一、程序和執行緒的定義 程序：程序是資源（CPU、記憶體等）分配的基本單位，它是程式執行時的一個例項。程式執行時系統就會建立一個程序，併為它分配資源，然後把該程序放入程序就緒佇列，程序排程器選中它的時候就會為它分配CPU時間，程式開始真正執行。 執行緒：執行緒是程式執行時的最小單位，它是程序

java多執行緒--練習題總結

目錄   練題1:編寫程式實現,子執行緒迴圈3次,接著主執行緒迴圈5次,接著再子執行緒迴圈3次,主執行緒迴圈5次,如此反覆,迴圈3次. 練習題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1. 練習題3:自己編寫程式碼,實現生產者-消費者模

iOS開發多執行緒學習總結 - GCD的使用

文章內容和排版參考: iOS 多執行緒: [GCD]詳盡總結 GCD - 核心概念:  任務 | 佇列 任務: 就是指需要執行的程式碼, 在block中編寫,有 同步執行 和 非同步執行 兩種方式. 

多執行緒學習總結

只有一條執行路基的程式是單執行緒程式 有多條則為多執行緒  多程序意義:  增加cpu使用率,可以同一時間段內執行多個任務.  cpu某一個時間點只能做一件事情,只不過cpu在做程式間的高效切換   一個程序內多個任務,這個任務就是執行緒

#Java多執行緒知識點總結wait、notify、notifyAll

Java多執行緒 設計一個典型的場景，來闡述wait()、notify()、notifyAll()，生產消費者。 有生產者、消費者、緩衝佇列（size=10）。 生產者不停地向緩衝佇列裡放資料，一旦佇列滿了，則wait()，並notify()消費者進行處理。 消費者不停地從緩衝佇列裡

面試系列-40個Java多執行緒問題總結

前言 這篇文章主要是對多執行緒的問題進行總結的，因此羅列了40個多執行緒的問題。 這些多執行緒的問題，有些來源於各大網站、有些來源於自己的思考。可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，但是本文寫作的重心就是 所有的問題都會按照自己的理解

java ftp支援 多執行緒與否總結

問題發生的直觀描述：在使用者用Bootstarp Fileinput通過非同步的方式上傳多張圖片檔案至ftp時出現檔案有的成功，有的失敗。完全隨機的。 debug結論：在FtpClient.storeFile()時報connect is not open 的IO異常有的還有connect

【Java多執行緒併發總結】Thread類的常用方法(join、yield等)---執行緒的基礎操作篇

 啟動(start)   最基本的操作，呼叫Runnable中的run方法，無返回值。 new Thread(new Test()).start(); 休眠(sleep)  使當前執行緒休眠一段時間，預設為毫秒級，最高可以精確到納秒，呼叫的方法為slee

java值多執行緒的總結

java多執行緒的放肆有四種 1.繼承Thread類，重寫run方法。 2.實現Runnable介面，重寫run方法，實現Runnable介面的實現類例項物件作為Thread構造器函式的target. 3.通過Callable和FutureTask建立執行緒。 4.建立執行緒

java多執行緒知識總結

程序：一個程序包括由作業系統分配的記憶體空間，包含一個或多個執行緒。一個執行緒不能獨立的存在，它必須是程序的一部分。一個程序一直執行，直到所有的非守護執行緒都結束執行後才能結束。 多執行緒能滿足程式設計師編寫高效率的程式來達到充分利用 CPU 的目的。 詳細解釋： 程式：為了完成特定任務

winform 呼叫外部程式和多執行緒

1.呼叫外部程式 Process outProcess = new Process(); //初始化 outProcess.StartInfo.File

C#多執行緒個人總結

執行緒基礎使用 建立一個控制檯程式，利用ThreadStart委託建立一個執行緒： using System.Threading; public static void CallToChildThread() {

知識儲備—01-程序，執行緒，多執行緒相關總結

一、說說概念 1、程序（process） 狹義定義：程序就是一段程式的執行過程。 廣義定義：程序是一個具有一定獨立功能的程式關於某個資料集合的一次執行活動。它是作業系統動態執行的基本單元，在傳統的作業系統中，程序既是基本的分配單元，也是基本的執行單元。 簡單的來講程序的概念主要有兩點：第一，程序是一個實體。