2. 程式人生 > >線程基礎知識(一)

線程基礎知識(一)

阿新 • • 發佈：2018-05-23
讀後感 應用 rup IE osi 很好 state lee IT

線程基礎知識(一)

看了Java多線程編程核心技術第一章,算是讀後感吧感覺自己基礎並不是很好。

並發和並行

並發：你在吃飯突然來了一個電話，然後你去接電話，接完電話再吃飯。

並行：你在吃飯突然來了一個電話，然後你邊吃飯邊接電話。

並發其實就是交替的進行，並行就是同時進行。

技術分享圖片

技術分享圖片

進程和線程和程序

參考https://blog.csdn.net/woaigaolaoshi/article/details/51039505

程序並不能單獨執行，只有將程序加載到內存中，系統為他分配資源後才能夠執行，這種執行的程序稱之為進程，也就是說進程是系統進行資源分配和調度的一個獨立單位，每個進程都有自己單獨的地址空間。所以說程序與進程的區別在於，程序是指令的集合，是進程運行的靜態描述文本，而進程則是程序在系統上順序執行時的動態活動。

但是進程存在著很多缺陷，主要集中在兩點：

(1).進程只能在同一時間幹一件事情，如果想同時幹兩件事或多件事情，進程就無能為力了。

(2).進程在執行的過程中如果由於某種原因阻塞了，例如等待輸入，整個進程就會掛起，其他與輸入無關的工作也必須等待輸入結束後才能順序執行。

為了解決上述兩點缺陷，引入了線程這個概念。

線程是進程的一個實體,也是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位，有時又被稱為輕權進程或輕量級進程，相對進程而言，線程是一個更加接近於執行體的概念，進程在執行過程中擁有獨立的內存單元，而線程自己基本上不擁有系統資源，也沒有自己的地址空間，只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),線程的改變只代表了 CPU 執行過程的改變，而沒有發生進程所擁有的資源變化。除了CPU 之外，計算機內的軟硬件資源的分配與線程無關，但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。

舉個例子吧，QQ是騰訊的一個應用也是一個程序，當我們雙擊QQ輸入賬號和密碼點擊登錄時(將程序加載到內存中，系統為他分配資源)這就是一個進程。你可以打開任務管理器查看下。

技術分享圖片

要是你想找小明同學聊天，小紅同學聊天...打開的窗口就是線程。

Thread類和Runnable接口

繼承Thread類重寫run()方法

class MyThread extends Thread{
@Override
public void run(){
    System.out.println(Thread.currentThread().getName());
}

實現Runnable接口

class MyRunnable implements Runnable{

@Override
public void run() {
    System.out.println("myRunnable:"+Thread.currentThread().getName());
}
}

public class Test {
public static void main(String[] args) {
    MyThread thread=new MyThread();
    thread.start();
    Thread thread1=new Thread(new MyRunnable());
    thread1.start();
}
}

推薦使用Runnable，因為java是單繼承有局限性，而接口是多"繼承"(實現多個接口)。

幾個方法

currentThread()獲取當前線程

public class Test {
public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName());
}
}

技術分享圖片

isAlive()方法判斷當前線程是否活著

public class Test {
public static void main(String[] args) {
    MyThread thread=new MyThread();
    thread.start();
    System.out.println(thread.isAlive());
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(thread.isAlive());

}
}

class MyThread extends Thread{
@Override
public void run(){
    System.out.println(Thread.currentThread().getName());
}
}

技術分享圖片

sleep()當前線程休眠讓出cpu使用，但是不讓出鎖 wait 會讓出鎖使用

public class Test {
    public static void main(String[] args) {
        MyRunnable runnable=new MyRunnable();
        Thread thread=new Thread(runnable);
        Thread thread1=new Thread(runnable);
        Thread thread2=new Thread(runnable);
        Thread thread3=new Thread(runnable);
        Thread thread4=new Thread(runnable);
        Thread thread5=new Thread(runnable);
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        synchronized (Test.class) {
            System.out.println("myRunnable:" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}



public class TestThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        Thread thread1=new Thread(myThread);
        Thread thread2=new Thread(myThread);
        Thread thread3=new Thread(myThread);
        Thread thread4=new Thread(myThread);
        Thread thread5=new Thread(myThread);
        Thread thread6=new Thread(myThread);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
        thread6.start();

    }
}

class MyThread extends Thread{

    @Override
    public synchronized void run(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
}

技術分享圖片

wait(),notify(),notifyAll()是屬於Object類中。調用這3個方法時需要持有當前對象鎖資源不然會有java.lang.IllegalMonitorStateException 異常

生產者消費者。

public class PCModel {
    public static void main(String[] args) {
        //初始化storeHouse的大小
        int storeHouseSize=10;
        PriorityQueue<Integer> storeHouse=new PriorityQueue<>(storeHouseSize);
        Thread producer=new Thread(new Producer(storeHouse));
        Thread consumerOne=new Thread(new Consumer(storeHouse));
        Thread consumerTwo=new Thread(new Consumer(storeHouse));
        producer.start();
        consumerOne.start();
        consumerTwo.start();


    }



}

class Consumer implements Runnable{
    private Queue<Integer> storeHouse;
    public Consumer(Queue<Integer> storeHouse){
        this.storeHouse=storeHouse;
    }
    @Override
    public void run() {
        consume();
    }

    private void consume(){
        while(true){
            synchronized (storeHouse){
                while(storeHouse.size()==0){
                    try {
                        storeHouse.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //出隊列
                storeHouse.poll();
                System.out.println(Thread.currentThread().getName()+"消費了一個");
                storeHouse.notifyAll();
            }
        }
    }
}


class Producer implements Runnable{
    private Queue<Integer> storeHouse;
    public Producer(Queue<Integer> storeHouse){
        this.storeHouse=storeHouse;
    }
    @Override
    public void run() {
        produce();
    }

    private void produce(){
        while (true){
            synchronized (storeHouse){
                while (storeHouse.size()==10){
                    try {
                        storeHouse.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //生產
                storeHouse.add(1);
                System.out.println(Thread.currentThread().getName()+"添加了一個");
                storeHouse.notifyAll();
            }
        }
    }
}

getId()獲取線程的唯一標識

/**
 * Returns the identifier of this Thread.  The thread ID is a positive
 * <tt>long</tt> number generated when this thread was created.
 * The thread ID is unique and remains unchanged during its lifetime.
 * When a thread is terminated, this thread ID may be reused.
 *
 * @return this thread's ID.
 * @since 1.5
 */
public long getId() {
    return tid;
}

interrupted(),isInterrupted(),interrupt()

public class TestThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        System.out.println(myThread.isInterrupted());
        myThread.interrupt();
        System.out.println(myThread.isInterrupted());

    }
}

class MyThread extends Thread{

    @Override
    public synchronized void run(){
        for(int i=1;i<1000;i++){
            System.out.println(Thread.currentThread().getName()+"     "+i);
        }
    }
}

interrupt()不能停止線程，只是在打個停止的標記。isInterrupted()判斷線程是否已經中斷。

public class TestThread {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println(Thread.interrupted());
        System.out.println(Thread.interrupted());
    }
}

interrupted()判斷當前線程是否中斷。interrupted()具有清除狀態功能。如上面結果第二次調用返回false。

線程在wait或sleep期間被中斷會拋出InterruptedException

public class TestThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        myThread.interrupt();
    }
}

class MyThread extends Thread{

    @Override
    public synchronized void run(){
        try {
            Thread.sleep(10000);
            //this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

一般當你調用sleep()方法或wait()方法後會自動提示你有異常要處理。

stop()方法為什麽被拋棄

public class TestThread {
    public static void main(String[] args) {
        Person person=new Person("aaaaaaaaaa","1");
        MyThread myThread=new MyThread(person);
        myThread.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.stop();
        System.out.println(person.getName()+"    "+person.getAge());

    }
}

class MyThread extends Thread{
    private Person person;

    public MyThread(Person person){
        this.person=person;
    }

    @Override
    public synchronized void run(){
        System.out.println(person.getName()+"    "+person.getAge());
        person.setName("abcd");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        person.setAge("20");
        System.out.println(person.getName()+"    "+person.getAge());

    }
}

class Person{
    //姓名
    private String name;
    //年齡
    private String age;

    public Person(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

stop()方法會造成數據不一致。

suspend()和resume()方法為什麽被拋棄

public class TestThread {
    public static void main(String[] args) {
        Person person = new Person("aaaa", 15);
        MyRunnable myRunnable = new MyRunnable(person);
        Thread thread = new Thread(myRunnable);
        thread.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        person.setName("xiaoming");
        Thread thread1 = new Thread(new MyRunnable(person));
        thread1.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        person.setName("AAAA");
        Thread thread2 = new Thread(new MyRunnable(person));
        thread2.start();


    }
}

class MyRunnable implements Runnable {
    private Person person;

    public MyRunnable(Person person) {
        this.person = person;
    }

    @Override
    public void run() {
        this.person.say();
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public synchronized void say() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (name.equals("xiaoming"))
            Thread.currentThread().suspend();
        else
            System.out.println("name: " + this.name + " age:" + age);
    }
}

當把name改成xiaoming後第二個線程就一直占有資源，線程3進不去。

使用suspend與resume方法時使用不當會造成公共同步對象的獨占。

使用suspend與resume方法時會造成數據不同步。

yield方法的作用是放棄當前CPU資源，但放棄時間不確定

public class TestThread {
    public static void main(String[] args) {
       Thread thread=new Thread(new MyRunnable());
       thread.start();


    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        long start=System.currentTimeMillis();
        for (int i=0;i<1000000000;i++);
        Thread.yield();
        long end=System.currentTimeMillis();
        System.out.println(end-start);
    }
}

線程優先級高獲取的cpu資源比較多，線程中的優先級具有繼承性

public class TestThread {
    public static void main(String[] args) {
        FatherThread fatherThread = new FatherThread();
        SonThread sonThread = new SonThread();
        //優先級具有繼承性
        System.out.println("Father Priority:" + fatherThread.getPriority());
        System.out.println("Son Priority:" + sonThread.getPriority());


    }
}

class FatherThread extends Thread {
    @Override
    public void run() {
        System.out.println("Father");
    }
}

class SonThread extends FatherThread {

}

守護線程

以前太了解守護線程是幹啥的。現在知道守護線程就是為其他線程服務的等其它線程結束它才會結束。比如垃圾回收線程。

public class TestThread {
    public static void main(String[] args) {
        MyThread thread=new MyThread();
        thread.setDaemon(true);
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                System.out.println(i);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

如何停止線程

使用interrupt()與return結合

public class TestThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.interrupt();



    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            if (this.isInterrupted()){
                System.out.println("Stop>>>>>>>>>>>>");
                return;
            }
            else
                System.out.println(System.currentTimeMillis());
        }
    }
}

總結

主要是Java多線程編程核心技術第一章的讀後感自己也動手敲了一遍對一些線程基礎理解更加深入了。加油加油！如果有一些問題歡迎指出來感謝。

線程基礎知識(一)

相關推薦

線程基礎知識(一)

讀後感 應用 rup IE osi 很好 state lee IT 線程基礎知識(一) 看了Java多線程編程核心技術第一章,算是讀後感吧感覺自己基礎並不是很好。 並發和並行 並發：你在吃飯突然來了一個電話，然後你去接電話，接完電話再吃飯。 並行：你在吃飯突然來了一個電

多線程基礎知識（二）

必須 否則 closed form 自己 back play sender 重點 線程池 因為每次創建線程、銷毀線程都比較消耗 cpu 資源，因此可以通過線程池進行優化。線程池是一組已經創建好的線程，隨用隨取，用完了不是銷毀線程，然後放到線程池中，供其他人用。 用線程池之

線程基礎知識

sync 可執行 垃圾回收器 tar 棧和堆 object 中一 聲明 退出 首先了解一下JVM、棧和堆1棧：JVM中一個線程一個棧內存，棧內存是獨立的，棧中儲存局部變量，所以局部變量的內存不共享，不會存在線程問題。2堆：JVM中只有一個堆，堆內存是多線程共享的，堆內存中儲

線程基礎知識(三)

thrown 但是 runnable take 停止 reader RR min tcp wait、notify、notifyAll wait、sleep、yield區別？ sleep 讓出cpu使用權但是不會釋放鎖。 public class Test { public

Shell編程基礎知識(一)

ble 啟動 繼承 ignore 負數 -s 系統 限制 出了 一.基本的運行Linux程序的3種方法： (1) 使文件具有可執行權限，直接運行文件。eg: chmod a+x testfile.sh ./testfile.sh (2) 直接調用命令解釋器來執行程序。

多線程基礎知識簡介

一段 cond add sleep star 一、基本概念 運行 多線程基礎 技術 一、基本概念：程序、進程、線程 程序（program）：是為完成特定任務、用某種預研編寫的一組指令的集合。即指一段靜態的代碼，靜態對象 進程（process）：是程序的依次執行過程，

多線程基礎一之（線程的3種實現方式）

font dem cep urn led ring ble new t println 實現線程的三種方式： （1）繼承Thread類，重寫Run方法　 class MyThreadDemo extends Thread { @Override publi

一、Java多線程基礎

threading oob ldd stack idt add ron ref 隨著 一、簡介 1、操作系統 在早起的裸機時代，計算機非常地昂貴，而且也沒有操作系統的概念，計算機從頭到尾只能執行一個程序。如果程序在執行一個耗時的操作，那麽在這個過程中，計算機就有大量的資

c++並發編程基礎（一）：並發、並行域多線程

競爭 安全 開發 引用 詳解 輕量 事情 地址空間 var 正文 C++11標準在標準庫中為多線程提供了組件，這意味著使用C++編寫與平臺無關的多線程程序成為可能，而C++程序的可移植性也得到了有力的保證。另外，並發編程可提高應用的性能，這對對性能錙銖必較的C++程序員來

多線程學習一（多線程基礎）

rdquo 走了 更多 program 額外 這一 正在 runnable 創建 前言 多線程、單線程、進程、任務、線程池...等等一些術語到底是什麽意思呢？到底什麽是多線程？它到底怎麽用？我們一起來學習一下多線程的處理 如何理解 進程：進程是給定

Java 多線程基礎

xtend 當前 nds nth list 相同 pid 概念 主線程 1.多線程基礎 1）進程 　　進程（process）就是一塊包含了某些資源的內存區域。操作系統利用進程把它的工作劃分為一些功能單元。進程中所包含的一個或多個執行單元成為線程（threa

Java線程詳解(一)

線程 thread runnable 程序、進程、線程的概念 程序(program)：是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態的代碼，靜態對象。 進程(process)：是程序的一次執行過程，或是正在運行的一個程序。動態過程：有它自身的產生、存在和消亡的過程。 如

Java多線程基礎（二）

常用 進程上下文 技術 進入 返回 ren 說明 多線程基礎 常用api 基本概念 進程：程序的執行過程。持有資源（共享內存、共享文件）和線程。 線程： - 是一個程序內部的順序控制流。 - 它包含在進程之中，是系統中最小執行單元，同一個進程可以有多個線程。 - 線程共享進

iOS開發中多線程基礎

推斷 傳遞 cti self reads priority cal default value 耗時操作演練 代碼演練 編寫耗時方法 - (void)longOperation { for (int i = 0; i <

java 內存模型和多線程基礎

java 技術 blog 分享 nbsp 多線程基礎 ima image ges java 內存模型和多線程基礎

java多線程基礎

很難 thread 結束 就會 線程 () cpu zed ron wait和notify是針對sychronized鎖定對象的 sychronized(object)object.wait();//釋放object的鎖sychronized(object)object.n

【Java系列】【基礎版】多線程基礎

java多線程基礎1.1 認識進程和線程1.1.1 什麽是進程 1.1.1.1 進程是正在進項的程序，是資源分配的一個基本單位，有內存分配；1.1.2 什麽是線程 1.1.2.1 線程是進程的一個執行單位，也是進程的執行順序； 1.1.2.2 一個進程至少有一個線程，可以由兩個或以上的線程

計算機基礎知識一

ref -1 常用 計算機基礎 jce tex clas text 分隔 . 在這裏表示的是當前目錄，就像 .. 表示上級目錄一樣。這個 / 表示的是目錄級別的分隔符，他之前的就是目錄名，./aaa/ 表明的就是 . （也就是當前目錄）下面的 aaa 目錄。當然這個 aaa

C#多線程基礎，適合新手了解

net 應用程序 sin pri rgs 工作 而在 了解 thread 一、創建線程 　　在整個系列文章中，我們主要使用Visual Studio 2015作為線程編程的主要工具。在C#語言中創建、使用線程只需要按以下步驟編寫即可： 1、啟動Visual Studio

001-多線程基礎-進程線程、線程狀態、優先級、用戶線程和守護線程

我們 row 上進 最好 left 同一時間 set 關系 dos系統 一、進程與線程 1、DOS系統【單進程系統】 　　最早的時候DOS有一個特點：只要電腦有病毒，那麽電腦就死機了。　　原因：傳統的DOS系統屬於單進程系統，即：在同一時間段內只允許有一個程序運行。