2. 程式人生 > >Java 線程寶典

Java 線程寶典

阿新 • • 發佈：2017-08-14
種類 定義 rac 接口 demo art div ram 當前

此文 為垃圾文 本人復習用的 emmm

  • 多線程：指的是這個程序（一個進程）運行時產生了不止一個線程
  • 並行與並發：
    • 並行：多個cpu實例或者多臺機器同時執行一段處理邏輯，是真正的同時。
    • 並發：通過cpu調度算法，讓用戶看上去同時執行，實際上從cpu操作層面不是真正的同時。並發往往在場景中有公用的資源，那麽針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力。

　　進程和線程的區分

　　第一種實現方式:通過繼承Thread類來實現的 線程

　　　 摘要:

　　技術分享

code:

package com.java.Thread;

public class MyThread {
    
 
public static void main(String[] args){
        Apple a1 = new Apple("壞蛋");
            a1.start();
        Apple a2 = new Apple("好人");
            a2.start();
    }
}
class Apple extends Thread{
    private String name;

    public  Apple(String name){
        this.name = name;
    }

    public void
 
 run(){
        for (int i = 1; i < 10; i++){
            System.out.println(name+""+i);
        }
    }

}

每一個線程從的它的創建到銷毀都有一個狀態 如下是線程的各種狀態:

技術分享

線程的四種狀態

技術分享

然後實現現成的 第二種方式 實現 Runnable接口

　　技術分享

code如下:

package cn.java.thread;

public class RunnableDemo {

    public static void main(String[] args) {
        Test t1 
 
= new Test("haoren");
        Test t2 = new Test("hairen");
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t2);
        th1.start();
        th2.start();
    }

}

class Test implements Runnable{
    private String name;
    
    public  Test(String name){
        this.name = name;
    }
    
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(name+":"+i);
        }
    }
}

　　Thread和Runnable的關系

1.Thread是Ruuable的之類

　　 2.實際上Thread和Runable的關系 跟代理設計模式很像， 這裏的Thread就是代理類。我們自己所實現的類才是real。

　　　Thread和Runnable的區別

　　　 Runable可以共享數據

code如下:

package cn.java.thread;

public class ShareDemo {
    public static void main(String[] args) {
        Tickets t1 = new Tickets();
        
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t1);
        th1.start();
        th2.start();
        
        
    }

}

class Tickets implements Runnable{
    private int ticket = 5;
    
    public void run(){
        for(int i=0;i<5;i++){
            if(ticket>0)
            System.out.print(ticket--);
            
        }
    }
}

然後 我說說這裏面的 一個叫做jojn()的東東 網上各種帖子眾說紛紜 而對他的理解就是 4個字 強制執行 做一個簡單的驗證吧.

package com.java.Thread;

public class MyJoin {
    public static void main(String[] ARGS){
        MyThread2 mt1 = new MyThread2();
        mt1.setName("線程1");
        mt1.start();
        for (int i = 0; i < 10; i++) {
            if(i==5){
                try {
                    mt1.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
            System.out.println(i);
        }


    }
}
class MyThread2 extends Thread {
    /*public MyThread(String string) {
    }*/

    public void run() {
        int i = 0;
        while (i < 10) {
            System.out.println(Thread.currentThread().getName());
            i++;
        }


    }
}

運行結果如下

技術分享

然後在 說說 interrupt 中斷 一個線程意味著在該線程完成任務之前停止其正在進行的一切，有效地中止其當前的操作。線程是死亡、還是等待新的任務或是繼續運行至下一步，就取決於這個程序。雖然初次看來它可能顯得簡單，但是，你必須進行一些預警以實現期望的結果。你最好還是牢記以下的幾點告誡。

首先，忘掉Thread.stop方法。雖然它確實停止了一個正在運行的線程，然而，這種方法是不安全也是不受提倡的，這意味著，在未來的Java版本中，它將不復存在。

一些輕率的家夥可能被另一種方法Thread.interrupt所迷惑。盡管，其名稱似乎在暗示著什麽，然而，這種方法並不會中斷一個正在運行的線程（待會將進一步說明），正如Listing A中描述的那樣。它創建了一個線程，並且試圖使用Thread.interrupt方法停止該線程。Thread.sleep()方法的調用，為線程的初始化和中止提供了充裕的時間。線程本身並不參與任何有用的操作。

code如下:

package com.java.Thread;

public class MyInterrupt {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread3 mt = new MyThread3();
        mt.start();

        try {
            Thread.sleep(2000);
            System.out.println("main休眠結束");
        } catch (InterruptedException e) {

            e.printStackTrace();
        }

        mt.interrupt();

    }
}

class MyThread3 extends Thread{
    public void run(){
        System.out.println("進入run");
        try {
            Thread.sleep(8000);

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            //e.printStackTrace();
            System.out.println("run休眠結束！！！");//sleep被中斷會拋出InterruptedException 推薦直接拋出 不要捕獲
        }
        System.out.println("run運行結束");
    }

}

然後來到線程禮讓 俗話點說 就是 線程A是個君子 看見線程B是個 美女就幹什麽都讓著她 讓她先過..

code如下:

package com.java.Thread;
//線程禮讓
public class MyYield {
    public static void main(String[] ARGS){
        MyThred m1 = new MyThred();
            Thread t1 = new Thread(m1,"李四");
            Thread t2 = new Thread(m1,"王五");
            t1.start();
            t2.start();
    }
}
class MyThred implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName()+"運行>>>>>" + i);
            if (i==2) {
                System.out.println("線程禮讓");
                Thread.currentThread().yield();
            }
        }
    }
}

然後 來到 setdaenmo 後臺線程設置

Java中線程分為兩種類型：用戶線程和守護線程。通過Thread.setDaemon(false)設置為用戶線程；通過Thread.setDaemon(true)設置為守護線程。如果不設置次屬性，默認為用戶線程。

用戶線程和守護線程的區別：

1. 主線程結束後用戶線程還會繼續運行,JVM存活；主線程結束後守護線程和JVM的狀態又下面第2條確定。

2.如果沒有用戶線程，都是守護線程，那麽JVM結束（隨之而來的是所有的一切煙消雲散，包括所有的守護線程）。

code如下:

package com.java.Thread;

public class SetDaemon {
    public static void main(String[] ARGS){
        Persons p1 = new Persons();
            Thread th = new Thread(p1);
                th.setDaemon(true);//如果不加此語句就永遠無法結束
        th.start();

    }
}
class Persons implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("哈哈哈哈哈哈sss");
        }
    }
}

然後 設置線程的優先級別 這點要說說 高的不一定會優先執行.

這是定義表

技術分享

通過 setPriority方法來執行

技術分享

來到重點中的重點 拿個小本本記住 線程安全

　　導致線程安全出現的原因:

技術分享

技術分享

所以 我們為了解決這個問題 推出了 同步 synchronized

　　技術分享

然後同步又有兩種模式 一種是同步代碼塊 另外一種是同步函數 這兩種同步加鎖的方式不一樣 = =且看我細細道來

　　先看看code

package cn.tread;

public class TicketDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Person2 p1 = new Person2("haoren");
        Thread t1 = new Thread(p1);
        Thread t2 = new Thread(p1);
        t1.start();
        t2.start();

    }

}

class Person2 implements Runnable {
    private String name;
    private int tickets = 5;

    public Person2(String name) {
        this.name = name;
    }
　　　//同步代碼塊 需要的鎖是 任意對象~
    Object object1 = new Object();

    public void run() {

        for (int i = 0; i < 5; i++) {
            synchronized (object1) {//object1就是傳說中的鎖，要同步必須使用同一個鎖
                if (tickets > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }

                    System.out.println(tickets--);
                }
            }
        }

    }
}

觀察上面的代碼 我們 有了一個總結 同步代碼的鎖可以是任意對象

然後是同步的前提

技術分享

技術分享

同步的弊端

技術分享

然後我們說說同步函數

package cn.java.thread;

/*
 證明同步函數用的是this這把鎖
 */
public class Tickets1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         * GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
         * GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
         * gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
         * gt3.start();
         */
        GetTickets2 gt = new GetTickets2();
        Thread th1 = new Thread(gt, "窗口一");
        Thread th2 = new Thread(gt, "窗口二");
        Thread th3 = new Thread(gt, "窗口三");
        th1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        gt.flag = true;
        th2.start();
        th3.start();
    }

}

class GetTickets2 implements Runnable {

    private int tickets = 10;
    boolean flag = false;
    Object ob = new Object();
    public void run() {
        if (flag) {
            for (int i = 0; i < 10; i++) {
                //synchronized (ob) {//如果用ob就無法同步
                synchronized (this) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()
                                + "賣出" + (tickets--) + "號票"+":同步代碼塊");
                    }
                }
                
            }
            
        } else {
            for (int i = 0; i < 10; i++) {
                function();
                
            }

        }
    }

    public synchronized void function() {

        if (tickets > 0) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "賣出"
                    + (tickets--) + "號票"+"：同步函數");
            
        }
    }

}
/*
 * class GetTickets extends Thread{ //private static int tickets = 10; private
 * int tickets = 10; public void run(){
 * 
 * for (int i = 0; i < 10; i++) { if(tickets>0){
 * System.out.println(Thread.currentThread().getName()+"賣出"+(tickets--)+"號票"); }
 * } } }
 */

通過 觀察我們不難發現

技術分享

余下的我在下一個分P寫...

Java 線程寶典

相關推薦

Java 線程寶典

種類 定義 rac 接口 demo art div ram 當前 此文 為垃圾文 本人復習用的 emmm 多線程：指的是這個程序（一個進程）運行時產生了不止一個線程 並行與並發： 並行：多個cpu實例或者多臺機器同時執行一段處理邏輯，是真正的同時。 並發：通過cpu調度

Java 線程第三版 第五章 極簡同步技巧 讀書筆記

prev ear ont java else 停止 第三版 不同的 結合 一、能避免同步嗎？ 取得鎖會由於下面原因導致成本非常高： 取得由競爭的鎖須要在虛擬機的層面上執行很多其它的程序代碼。 要取得有競爭鎖的線程總是必須等到鎖被釋放後。 1. 寄

java線程（四）

讀寫 img 其他 手動 dem com 字段 只讀 停止線程 java5線程並發庫 　　線程並發庫是JDK 1.5版本級以上才有的針對線程並發編程提供的一些常用工具類，這些類被封裝在java.concurrent包下。 　　該包下又有兩個子包，分別是atomic和lock

java線程

所有 提取 特性 兩個 自動 通過 其他 view 子查詢 我曾遇到一個項目的數據庫中視圖比表還要多很多（表和視圖加起來上千個），幾乎每個表都有對應的視圖，而且有很多視圖長得相似，比如有些視圖關聯的表一樣，只是查詢列表多或少了一兩個字段。我敢斷定，這就是因為一些水平低劣的開

Java線程安全 關於原子性與volatile的試驗

har length rgs 無法 over pub boolean 即使 dex 1. 變量遞增試驗 1 static /*volatile*/ int shared=0;//volatile也無法保證++操作的原子性 2 static synchr

java線程總結--synchronized關鍵字，原理以及相關的鎖

public 關鍵字 多線程 java 文章 在多線程編程中，synchronized關鍵字非常常見，當我們需要進行“同步”操作時，我們很多時候需要該該關鍵字對代碼塊或者方法進行鎖定。被synchronized鎖定的代碼塊，只能同時有一條線程訪問該代碼塊。上面是很多人的認識，當然也是我之前

Java 線程池的原理與實現

控制 try 所在 使用 urn str waiting media .info 這幾天主要是狂看源程序，在彌補了一些曾經知識空白的同一時候，也學會了不少新的知識（比方 NIO）。或者稱為新技術吧。 線程池就是當中之中的一個，一提到線程。我們會想到曾經《操作系統》的

Java線程演示樣例 - 繼承Thread類和實現Runnable接口

無法 ads rup args dex rom 一個 nts future 進程（Process）和線程（Thread）是程序執行的兩個基本單元。Java並發編程很多其它的是和線程相關。 進程 進程是一個獨立的執行單元，可將其視為一個程序或應用。然而，一

Java線程池關閉1-shutdown和isTerminated<轉>

ride shu csdn nat err interrupt .net fin cat shutdownvoid shutdown()啟動一次順序關閉，執行以前提交的任務，但不接受新任務。若已經關閉，則調用沒有其他作用。拋出：SecurityException - 如果安

[Java]線程池

sta 狀態 lsi fun man his prop () mil 在沒有看不論什麽代碼之前首先想一下線程池應該有哪幾部分： 任務隊列線程 任務隊列非常好辦，直接用堵塞隊列就能夠了：BlockingQueue<Runnable> workQueue。

java線程用法

method 線程 art oid static stub ner java ring package com; public class Demo { public static void main(String[] args) {

Java線程池

程序 運行 fix 更新 exec span 新的 回收 所有 CachedThreadPool 會在程序執行過程中通常會創建與所需數量想用的線程，然後在它回收舊線程時，停止創建新的線程，因此它是合理的Excecutor的首選。 只有當這種方式會引發問題時，你猜需要

Java線程詳解(一)

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

java 線程協作 join()

java在實際開發中我們往往會遇到這樣的情況一個線程的執行需要依賴另一個線程執行後的結果。即主線程生成並起動了子線程，如果子線程裏要進行大量的耗時的運算，主線程往往將於子線程之前結束，但是如果主線程處理完其他的事務後，需要用到子線程的處理結果，也就是主線程需要等待子線程執行完成之後再結束，這個時候就要用到jo

java線程安全問題之靜態變量、實例變量、局部變量

通過 技術 安全 實踐 共享 pub net current 聲明 Java多線程編程中，存在很多線程安全問題，至於什麽是線程安全呢，給出一個通俗易懂的概念還是蠻難的，如同《java並發編程實踐》中所說： 寫道 給線程安全下定義比較困難。存在很多種定義，如：“一個類在可以被

Java線程池的分析和使用

服務器 dex man nan generate att width 微秒 cpu 1. 引言 合理利用線程池能夠帶來三個好處。第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。第二：提高響應速度。當任務到達 時，任務可以不需要的等到線程創建就

JAVA 線程與線程池簡單小結

執行 簡單 方式 線程池 str -s get() cache read JAVA線程創建方式： 1、繼承Thread類創建線程類 繼承Thread類並重寫該類的run方法，該un方法代表了線程要完成的任務。 2、通過Runnable接口創建線程類 實現runnable接口

java線程詳細介紹

star 異步 alt 繼承 問題 喚醒 sof 指定 cti 目錄(?)[-] 一擴展javalangThread類 二實現javalangRunnable接口 三Thread和Runnable的區別 四線程狀態轉換 五線程調度 六常用函數說明 使用方式 為什麽要用j

JAVA線程同步 （三）信號量

ole 給定 如何 package 分配 exec 大量 復制代碼 離開 一個信號量有且僅有3種操作，且它們全部是原子的：初始化、增加和減少 增加可以為一個進程解除阻塞； 減少可以讓一個進程進入阻塞。 信號量維護一個許可集，若有必要，會在獲得許可之前阻塞每一個線程：

Java線程狀態中BLOCKED和WAITING有什麽差別？

family osi amp block method flag ack san stack 剛才在看CSDN的問答時。發現這個問題。原問題的作者是在觀察jstack的輸出時提出的疑問。那麽BLOCKED和WAITING有什麽差別呢？ 答復在JDK源代碼中能夠