java多線程：ExecutorService方法詳解

原創 zhaoliubao1 2020-06-22 23:31

 1.ExecutorService是java多線程併發包下比較底層也是比較重要的接口，瞭解該接口中的方法的和每個方法的作用是非常有必要的，那麼我們現在就來看看每個方法的具體作用。

如圖我們可以看到ExecutorService的所有方法：

接下來對每個方法做具體的瞭解。其中shutdown(),shutdownNow(),isShutDown(),submit()相關方法前面已經介紹過，這裏不做重複工作，想了解請移步https://blog.csdn.net/zhaoliubao1/article/details/102939488和https://blog.csdn.net/zhaoliubao1/article/details/103120089做詳細瞭解。本文只對invoke*()相關方法做了解。

 

2.invokeAny(Collection<? extends Callable<T>> tasks);

方法：

源碼翻譯：Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwin an exception), if any do. Upon normal or exceptional return, tasks that have not completed are cancelled.The results of this method are undefined if the given collection is modified while this operation is in progress.（執行給定的任務，返回第一個已經執行完的結果（如果沒有拋出異常【這裏是指的是程序員手動的拋出異常，而不是調用這invokeAny時發生異常】。正常或者異常返回【這裏的異常指的是調用invokeAny時本身發生了異常】，那麼那些未完成的任務將會被取消。但是在執行過程中tasks如果被改變那麼返回的結果將不確定。））

《java併發編程：核心框架與核心方法》：invokeAny取得第一個完成的任務的結果值，當第一個任務執行完成後，會調用interrupt()方法來將其他任務中斷。【個人覺得這個描述相當精髓，精髓之處在於他提到了使用interrupt()去中斷其他任務，如果沒有提到這個那麼下面的試驗結果將會與源碼中的解釋相悖，至此我們對interrupt的工作機制瞭解就是非常重要的了，瞭解interruptd方法的工作機制移步到：https://blog.csdn.net/zhaoliubao1/article/details/102385808】

但是：

                                            （圖片來源：《java併發編程：核心框架與核心方法》） 

會出現上敘述的兩種情況。

接下來對上述論述進行試驗論證：

 

package com.springboot.thread.executorService;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestExecutorService {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        MyCallableA myCallableA = new MyCallableA();
        MyCallableB myCallableB = new MyCallableB();
        List<Callable<String>> callableList = new ArrayList<>();
        callableList.add(myCallableA);
        callableList.add(myCallableB);
        String result = executor.invokeAny(callableList);
        System.out.println(result);
    }
}

class MyCallableA implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableA begin at "+dateStr);
        //thread do sth.
        Thread.sleep(3000);
        System.out.println("MyCallableA end at "+dateStr);
        return "MyCallableA";
    }
}

class  MyCallableB implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableB begin at "+ dateStr);
        //thread do sth.
        Thread.sleep(5000);
        System.out.println("MyCallableB end at "+dateStr);
        return "MyCallableB";
    }
}

運行結果：

另一種情況：

 

package com.springboot.thread.executorService;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestExecutorService {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        MyCallableA myCallableA = new MyCallableA();
        MyCallableB myCallableB = new MyCallableB();
        List<Callable<String>> callableList = new ArrayList<>();
        callableList.add(myCallableA);
        callableList.add(myCallableB);
        String result = executor.invokeAny(callableList);
        System.out.println(result);
    }
}

class MyCallableA implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableA begin at "+dateStr);
        //thread do sth.
        //Thread.sleep(3000);
        for (int i=0;i<30;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableA "+(i+1));
        }
        System.out.println("MyCallableA end at "+dateStr);
        return "MyCallableA";
    }
}

class  MyCallableB implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableB begin at "+ dateStr);
        //thread do sth.
        //Thread.sleep(5000);
        for (int i =0; i<50;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableB "+(i+1));
        }
        System.out.println("MyCallableB end at "+dateStr);
        return "MyCallableB";
    }
}

運行結果：


MyCallableA begin at 2019-11-30 16:43:18
MyCallableA 1
MyCallableA 2
MyCallableA 3
MyCallableA 4
MyCallableA 5
MyCallableA 6
MyCallableA 7
MyCallableA 8
MyCallableA 9
MyCallableA 10
MyCallableA 11
MyCallableA 12
MyCallableA 13
MyCallableA 14
MyCallableA 15
MyCallableA 16
MyCallableA 17
MyCallableA 18
MyCallableA 19
MyCallableA 20
MyCallableA 21
MyCallableA 22
MyCallableA 23
MyCallableA 24
MyCallableA 25
MyCallableA 26
MyCallableA 27
MyCallableA 28
MyCallableA 29
MyCallableA 30
MyCallableA end at 2019-11-30 16:43:18
MyCallableB begin at 2019-11-30 16:43:18
MyCallableB 1
MyCallableB 2
MyCallableB 3
MyCallableB 4
MyCallableB 5
-------------------------
MyCallableA （MyCallableA 結束的標誌）
-------------------------
MyCallableB 6
MyCallableB 7
MyCallableB 8
MyCallableB 9
MyCallableB 10
MyCallableB 11
MyCallableB 12
MyCallableB 13
MyCallableB 14
MyCallableB 15
MyCallableB 16
MyCallableB 17
MyCallableB 18
MyCallableB 19
MyCallableB 20
MyCallableB 21
MyCallableB 22
MyCallableB 23
MyCallableB 24
MyCallableB 25
MyCallableB 26
MyCallableB 27
MyCallableB 28
MyCallableB 29
MyCallableB 30
MyCallableB 31
MyCallableB 32
MyCallableB 33
MyCallableB 34
MyCallableB 35
MyCallableB 36
MyCallableB 37
MyCallableB 38
MyCallableB 39
MyCallableB 40
MyCallableB 41
MyCallableB 42
MyCallableB 43
MyCallableB 44
MyCallableB 45
MyCallableB 46
MyCallableB 47
MyCallableB 48
MyCallableB 49
MyCallableB 50
MyCallableB end at 2019-11-30 16:43:18

上述的結果正是我所述的與源碼中的解釋相悖（看起來相悖）的運行結果。

 

手動拋出異常的試驗：

package com.springboot.thread.executorService;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestExecutorService {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        MyCallableA myCallableA = new MyCallableA();
        MyCallableB myCallableB = new MyCallableB();
        List<Callable<String>> callableList = new ArrayList<>();
        callableList.add(myCallableA);
        callableList.add(myCallableB);
        String result = executor.invokeAny(callableList);
        System.out.println(result);
    }
}

class MyCallableA implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableA begin at "+dateStr);
        //thread do sth.
        //Thread.sleep(3000);
        for (int i=0;i<30;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableA is running..."+(i+1));
        }
        if(1==1){
            System.out.println("MyCallableA occurred exception...");
            throw new NullPointerException("MyCallableA occurred exception...");
        }
        System.out.println("MyCallableA end at "+dateStr);
        return "MyCallableA";
    }
}

class  MyCallableB implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableB begin at "+ dateStr);
        //thread do sth.
        //Thread.sleep(5000);
        for (int i =0; i<50;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableB is running..."+(i+1));
        }
        System.out.println("MyCallableB end at "+dateStr);
        return "MyCallableB";
    }
}

運行結果：

MyCallableA begin at 2019-12-02 10:38:03
MyCallableB begin at 2019-12-02 10:38:03
MyCallableB is running...1
MyCallableB is running...2
MyCallableA is running...1
MyCallableB is running...3
MyCallableA is running...2
MyCallableB is running...4
MyCallableA is running...3
MyCallableB is running...5
MyCallableA is running...4
MyCallableB is running...6
MyCallableA is running...5
MyCallableA is running...6
MyCallableA is running...7
MyCallableB is running...7
MyCallableA is running...8
MyCallableA is running...9
MyCallableA is running...10
MyCallableB is running...8
MyCallableA is running...11
MyCallableB is running...9
MyCallableB is running...10
MyCallableB is running...11
MyCallableB is running...12
MyCallableB is running...13
MyCallableB is running...14
MyCallableB is running...15
MyCallableB is running...16
MyCallableB is running...17
MyCallableB is running...18
MyCallableA is running...12
MyCallableB is running...19
MyCallableA is running...13
MyCallableB is running...20
MyCallableA is running...14
MyCallableB is running...21
MyCallableA is running...15
MyCallableB is running...22
MyCallableA is running...16
MyCallableB is running...23
MyCallableA is running...17
MyCallableB is running...24
MyCallableA is running...18
MyCallableB is running...25
MyCallableA is running...19
MyCallableB is running...26
MyCallableA is running...20
MyCallableB is running...27
MyCallableA is running...21
MyCallableA is running...22
MyCallableA is running...23
MyCallableA is running...24
MyCallableA is running...25
MyCallableA is running...26
MyCallableA is running...27
MyCallableA is running...28
MyCallableB is running...28
MyCallableA is running...29
MyCallableA is running...30
--------------------------------------------------------
MyCallableA occurred exception...（MyCallableA 拋出異常）
--------------------------------------------------------
MyCallableB is running...29
MyCallableB is running...30
MyCallableB is running...31
MyCallableB is running...32
MyCallableB is running...33
MyCallableB is running...34
MyCallableB is running...35
MyCallableB is running...36
MyCallableB is running...37
MyCallableB is running...38
MyCallableB is running...39
MyCallableB is running...40
MyCallableB is running...41
MyCallableB is running...42
MyCallableB is running...43
MyCallableB is running...44
MyCallableB is running...45
MyCallableB is running...46
MyCallableB is running...47
MyCallableB is running...48
MyCallableB is running...49
MyCallableB is running...50
MyCallableB end at 2019-12-02 10:38:03
------------------------------------------
MyCallableB （MyCallableB 運行結束的標誌）
------------------------------------------

從運行結果來看：理論上講，MyCallableA 應該先於MyCallableB運行完，調用invokeAny()方法時會取得第一個運行完成的結果，但是由於在MyCallableA在運行過程中，出現了異常導致MyCallableA停止，但是並不拋出異常自己處理了，所以MyCallableB繼續執行然後返回。使用Try-Catch顯示拋出捕獲異常會有什麼樣的結果呢？

例子如下：

package com.springboot.thread.executorService;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestExecutorService {
    public static void main(String[] args) throws Exception {
        try {
            ExecutorService executor = Executors.newCachedThreadPool();
            MyCallableA myCallableA = new MyCallableA();
            MyCallableB myCallableB = new MyCallableB();
            List<Callable<String>> callableList = new ArrayList<>();
            callableList.add(myCallableA);
            callableList.add(myCallableB);
            String result = executor.invokeAny(callableList);
            System.out.println(result);
        }catch (Exception e){
            System.out.println(e.getMessage());
            //throw e;
        }

    }
}

class MyCallableA implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableA begin at "+dateStr);
        //thread do sth.
        //Thread.sleep(3000);
        try{
            for (int i=0;i<30;i++){
                Math.random();
                Math.random();
                Math.random();
                System.out.println("MyCallableA is running..."+(i+1));
            }
            if(1==1){
                System.out.println("MyCallableA occurred exception...");
                throw new NullPointerException("MyCallableA occurred exception...");
            }
            System.out.println("MyCallableA end at "+dateStr);

        }catch (Exception e){
           //throw  new Exception("MyCallableA occurred exception  caused the program to stop....");
            throw e;
        }

        return "MyCallableA";
    }
}

class  MyCallableB implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableB begin at "+ dateStr);
        //thread do sth.
        //Thread.sleep(5000);
        for (int i =0; i<50;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableB is running..."+(i+1));
        }
        System.out.println("MyCallableB end at "+dateStr);
        return "MyCallableB";
    }
}

運行結果：

MyCallableA begin at 2019-12-02 13:49:31
MyCallableA is running...1
MyCallableA is running...2
MyCallableA is running...3
MyCallableA is running...4
MyCallableA is running...5
MyCallableA is running...6
MyCallableA is running...7
MyCallableA is running...8
MyCallableA is running...9
MyCallableA is running...10
MyCallableA is running...11
MyCallableA is running...12
MyCallableA is running...13
MyCallableA is running...14
MyCallableA is running...15
MyCallableA is running...16
MyCallableA is running...17
MyCallableA is running...18
MyCallableA is running...19
MyCallableA is running...20
MyCallableA is running...21
MyCallableA is running...22
MyCallableA is running...23
MyCallableA is running...24
MyCallableA is running...25
MyCallableA is running...26
MyCallableA is running...27
MyCallableA is running...28
MyCallableA is running...29
MyCallableA is running...30
MyCallableA occurred exception...
MyCallableB begin at 2019-12-02 13:49:31
MyCallableB is running...1
MyCallableB is running...2
MyCallableB is running...3
MyCallableB is running...4
MyCallableB is running...5
MyCallableB is running...6
MyCallableB is running...7
MyCallableB is running...8
MyCallableB is running...9
MyCallableB is running...10
MyCallableB is running...11
MyCallableB is running...12
MyCallableB is running...13
MyCallableB is running...14
MyCallableB is running...15
MyCallableB is running...16
MyCallableB is running...17
MyCallableB is running...18
MyCallableB is running...19
MyCallableB is running...20
MyCallableB is running...21
MyCallableB is running...22
MyCallableB is running...23
MyCallableB is running...24
MyCallableB is running...25
MyCallableB is running...26
MyCallableB is running...27
MyCallableB is running...28
MyCallableB is running...29
MyCallableB is running...30
MyCallableB is running...31
MyCallableB is running...32
MyCallableB is running...33
MyCallableB is running...34
MyCallableB is running...35
MyCallableB is running...36
MyCallableB is running...37
MyCallableB is running...38
MyCallableB is running...39
MyCallableB is running...40
MyCallableB is running...41
MyCallableB is running...42
MyCallableB is running...43
MyCallableB is running...44
MyCallableB is running...45
MyCallableB is running...46
MyCallableB is running...47
MyCallableB is running...48
MyCallableB is running...49
MyCallableB is running...50
MyCallableB end at 2019-12-02 13:49:31
MyCallableB

從運行結果來看，就算我們顯式的拋出異常，主線程還是不捕獲異常，也就說明子線程出現異常事不影響主線程的運行。

 

當所有任務全部發生異常時：

package com.springboot.thread.executorService;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestExecutorService {
    public static void main(String[] args) throws Exception {
        try {
            ExecutorService executor = Executors.newCachedThreadPool();
            MyCallableA myCallableA = new MyCallableA();
            MyCallableB myCallableB = new MyCallableB();
            List<Callable<String>> callableList = new ArrayList<>();
            callableList.add(myCallableA);
            callableList.add(myCallableB);
            String result = executor.invokeAny(callableList);
            System.out.println(result);
        }catch (Exception e){
            System.out.println(e.getMessage());
            //throw e;
        }

    }
}

class MyCallableA implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableA begin at "+dateStr);
        //thread do sth.
        //Thread.sleep(3000);
        try{
            for (int i=0;i<30;i++){
                Math.random();
                Math.random();
                Math.random();
                System.out.println("MyCallableA is running..."+(i+1));
            }
            if(1==1){
                System.out.println("MyCallableA occurred exception...");
                throw new NullPointerException("MyCallableA occurred exception...");
            }
            //final  int i = 1 / 0;
            System.out.println("MyCallableA end at "+dateStr);

        }catch (Exception e){
           //throw  new Exception("MyCallableA occurred exception  caused the program to stop....");
            throw e;
        }

        return "MyCallableA";
    }
}

class  MyCallableB implements Callable<String>{

    @Override
    public String call() throws Exception {
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = dateformat.format(System.currentTimeMillis());
        System.out.println("MyCallableB begin at "+ dateStr);
        //thread do sth.
        //Thread.sleep(5000);
        for (int i =0; i<50;i++){
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableB is running..."+(i+1));
        }
        final  int i = 1 / 0;
        System.out.println("MyCallableB end at "+dateStr);
        return "MyCallableB";
    }
}

運行結果：

MyCallableA begin at 2019-12-02 14:46:46
MyCallableB begin at 2019-12-02 14:46:46
MyCallableA is running...1
MyCallableA is running...2
MyCallableA is running...3
MyCallableA is running...4
MyCallableA is running...5
MyCallableA is running...6
MyCallableA is running...7
MyCallableA is running...8
MyCallableA is running...9
MyCallableA is running...10
MyCallableA is running...11
MyCallableA is running...12
MyCallableA is running...13
MyCallableA is running...14
MyCallableA is running...15
MyCallableA is running...16
MyCallableB is running...1
MyCallableA is running...17
MyCallableB is running...2
MyCallableA is running...18
MyCallableA is running...19
MyCallableA is running...20
MyCallableA is running...21
MyCallableA is running...22
MyCallableA is running...23
MyCallableA is running...24
MyCallableA is running...25
MyCallableA is running...26
MyCallableA is running...27
MyCallableA is running...28
MyCallableA is running...29
MyCallableA is running...30
MyCallableA occurred exception...
MyCallableB is running...3
MyCallableB is running...4
MyCallableB is running...5
MyCallableB is running...6
MyCallableB is running...7
MyCallableB is running...8
MyCallableB is running...9
MyCallableB is running...10
MyCallableB is running...11
MyCallableB is running...12
MyCallableB is running...13
MyCallableB is running...14
MyCallableB is running...15
MyCallableB is running...16
MyCallableB is running...17
MyCallableB is running...18
MyCallableB is running...19
MyCallableB is running...20
MyCallableB is running...21
MyCallableB is running...22
MyCallableB is running...23
MyCallableB is running...24
MyCallableB is running...25
MyCallableB is running...26
MyCallableB is running...27
MyCallableB is running...28
MyCallableB is running...29
MyCallableB is running...30
MyCallableB is running...31
MyCallableB is running...32
MyCallableB is running...33
MyCallableB is running...34
MyCallableB is running...35
MyCallableB is running...36
MyCallableB is running...37
MyCallableB is running...38
MyCallableB is running...39
MyCallableB is running...40
MyCallableB is running...41
MyCallableB is running...42
MyCallableB is running...43
MyCallableB is running...44
MyCallableB is running...45
MyCallableB is running...46
MyCallableB is running...47
MyCallableB is running...48
MyCallableB is running...49
MyCallableB is running...50
java.lang.ArithmeticException: / by zero

當所有任務都發生異常時會拋出左後一個任務的異常，並使整個應用程序停止。

總結一下：使用invokeAny()方法時如果都沒有發生異常那麼會運行完所有任務並取第一個任務的結果，但是如果有一個任務有異常會取下一個任務的結果，拋出的異常不會被主線程捕獲到，全部發生異常時主線程會捕獲到最後一個任務的異常。超時時拋：

TimeOutException

（3）invokeAll()方法:invokeAll()方法會返回所有任務的執行結果，此方法的執行效果爲阻塞執行，要把所有的結果都取回時再繼續向下執行。只要有一個任務發生異常就拋出異常。快的任務沒有異常的話可以返回。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Java併發與多線程-詳解線程池

Java併發與多線程-詳解線程池 什麼是線程池？ 在此，我們參考一下百科的定義： 線程池（英語：thread pool）：一種線程使用模式。線程過多會帶來調度開銷，進而影響緩存局部性和整體性能。而線程池維護着多個線程，等待着監督

快乐柠檬 2020-07-07 20:23:31

連續 3 年最受歡迎：Rust，香！

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 阿里妹導讀：我們在選擇一種開發語言時會綜合考量各方面的特性，根據實際的需求適當取捨。魚和熊掌往往不可兼得，要想開發效率高，必然要犧牲性能

雲棲號資訊小編 2020-07-21 13:01:52

Python初學者的自我修養，找到自己的方向

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 上週的文章當中我們簡單介紹了線程和進程的概念，以及在Python當中如何在主線程之外創建其他線程，並且還了解了用戶級線程和後臺線程的區別以

雲棲號資訊小哥 2020-07-16 15:19:52

進程線程的的作用和區別

作者王奎     我的博客：www.marksaas.com 首先來回顧一下進程和線程的概念吧。 進程（Process)是計算機中已運行程序的實體。進程爲曾經是分時系統的基本運作單位。 線程（thread)是操作系統能夠進行運算調度的最小

MarkSaas 2020-07-08 11:46:10

窺探 kernel，just for fun --- sys_fork,sys_vfork,sys_clone,kernel_thread

本系列文章由張同浩編寫，轉載請註明出處：http://blog.csdn.net/muge0913/article/details/7479379 郵箱：[email protected] 用戶空間進程創

lengwuqin 2020-07-08 08:16:34

java ThreadLocal簡介與原理

網上看到很多ThreadLocal的文章，感覺上來就開始講原理，根本不講這是個啥。當然可能他們都知道這是個什麼東西，用在什麼場景下，爲什麼需要它出現；而我不知道……   ThradLocal是什麼 還是借用別人的說法： （1）Thre

flushmeteor 2020-07-08 04:14:10

Java知識點——線程通信（線程之間的聯繫）

1. 生活化例子 預約 --> 搶購 消費者 <–> 商品 <–> 生產者 消費者 1. 購買商品 2. 等待，不過在等待之前，需要告知生產者快點生產 生產者： 1. 生產商品 2. 休息，在休息之前，要告知消費者你快來買啊 商品

青柠小鱼码字猴 2020-07-08 03:45:43

基於ARM的嵌入式Linux移植真實體驗（4）――設備驅動

設備驅動程序是操作系統內核和機器硬件之間的接口，它爲應用程序屏蔽硬件的細節，一般來說，Linux的設備驅動程序需要完成如下功能： 　　Ø　　　　 設備初始化、釋放； 　　Ø　　　　 提供各類設備服務； 　　Ø　　　　 負責內核和設備之間的

jiangyaoyan 2020-07-08 02:36:55

小試JavaScript多線程

    這兩天一直在弄ajax，用多了才發現了ajax 的cache問題，請求了好多次，得到了確是相同的結果，經常我想在請求的同時去做一些其它的事情，我在想javascript裏有沒有辦法用多線程，經過在網上查找找到了結果。    法寶就

bhbhjackyin 2020-07-08 02:35:54

鼠標移動放大鏡效果

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; u

熙风 2020-07-08 02:22:21

java stop方法爲什麼不能用？

一方面stop線程非常粗暴，除非可能執行finally代碼塊以及釋放synchronized外，線程將直接被終止，非常粗暴，此外如果線程持有JUC的互斥鎖，還可能導致鎖來不及釋放，造成其他線程永遠等待的局面。 JUC是Lock不是

imagine0623 2020-07-08 01:18:27

關於C#Winform線程調用窗體的使用方法以及窗體的單一顯示

使用相關的具備條件： 1.前提是必須窗體實例完畢，再觸發相關事件開始調用 2.代碼如下：如在窗體加載完畢的一個button事件調用線程1  Thread th1= new Thread(new ThreadStart(proces

Joe-Fan 2020-07-07 22:28:44

【轉】Java:使用synchronized和Lock對象獲取對象鎖

在併發環境下，解決共享資源衝突問題時，可以考慮使用鎖機制。[b]1.對象的鎖[/b]所有對象都自動含有單一的鎖。JVM負責跟蹤對象被加鎖的次數。如果一

iteye_17543 2020-07-07 22:21:22

阻塞模式下socket多線程通信

客戶端創建線程負責收發數據，其餘操作封裝在函數中，方便其他應用程序調用。服務端創建了兩個線程，一個用於收發數據，對於接收連接accept部分開一個線程，這樣主窗口就不會因阻塞而掛掉。（ 參考資料：《Windows API開發詳解——函數、

JochenZou 2020-07-07 22:02:42

一段讀取文件時顯示進度條的代碼(CSDN上收錄)

using System;using System.Threading;using System.Drawing;using System.Collections;using System.ComponentModel;using Sys

tangyong12 2020-07-07 17:32:40