Java_マルチスレッドの基礎

カスタムスレッド

実装

Threadクラスの継承
Runnableを実装します

Threadクラスの継承

スレッドを継承した後、実行するメソッドをオーバーライドします
空公共RUN実行されるスレッドのタスクのメソッド本体
方法のためのスレッドを開始するスタート（） ）（代わりに、実行を呼び出すのでは、
新しいスレッドを開くことができませんrunメソッドを呼び出して、普通の関数呼び出し
クラスのライフサイクルのスレッドが一度だけ起動することができます

    public class xiancheng2 {

    public static void main(String[] args) {
            
        //创建对象
        Myrun  run1 =  new Myrun();
        //创建线程对象
        Thread  runTd = new Thread( run1 );
        // 开启线程
        runTd.start();
        run1.say();
    }
}

class Myrun extends Thread{
    @Override
    public void run() {
        System.out.println("新的线程");
    }
    
    public void say() {
        System.out.println( "美好的一天" );
    }
    
}

共通API

文字列のgetName（）	このスレッドの名前を返します。
長いのgetId（）	スレッドの識別子を返します。
int型getPriority（）	スレッドの優先順位を返します。
Thread.State getStateを（）	このスレッドの状態を返します。
参加します（）	このスレッドを待ちます。
参加（長いミリ秒）	ミリ秒（ミリ秒）の最大にこのスレッドを待ちます。
静的な無効スリープ（ロングミリ秒）	指定されたミリ秒数でスリープに現在実行中のスレッド（中断）。
無効開始（）
無効割り込み（）	割り込みスレッド。
静的ブールが中断（）	現在のスレッドが割り込まれているかどうかをテストします。
ブールisDaemon（）	このスレッドがデーモンスレッドであるかどうかをテストします。

Runnableを実装します

継承されたトレッドと類似している方法：
- 継承のRunnableインタフェース、実行する方法
- スレッドオブジェクトを作成し、オープンスレッド

違い

双方向インタフェースによって、より柔軟な（Javaは単一継承です）
簡単に継承方法。（めったに使われません）

スレッド状態

一般的に5つの状態によるスレッド
- 新しいステータス
- 心構え
- 動作状態
- 待機/ブロックされました
  - 睡眠：睡眠（）を呼び出します
  - 妨害：
  - 保留中：一時停止一時停止するコール、履歴書（）、オフホールド（推奨されません）
  - 待ち：コール待機（）
- 死の状態

使用糸

眠り

コール睡眠方法は、準備完了状態に入るように起きている前に、指定された時間のための睡眠のスレッドを可能に
- 公共の静的な無効スリープ（ロングミリ秒）スローInterruptedExceptionあります
- 公共の静的な無効スリープ（長いミリ、int型のnanos値）は例外：InterruptedExceptionを投げます

public class xiancheng2 {
    public static void main(String[] args) throws InterruptedException{
            
        //创建对象
        Myrun  run1 =  new Myrun();
        //创建线程对象
        Thread  runTd = new Thread( run1 );
        Thread  runTd2 = new Thread( run1 );
//       开启线程
        runTd.start();
        //使主线程睡眠100ms
        Thread.sleep(100);  
        System.out.println( "美好的一天" );
    }
}

class Myrun implements Runnable{
    
    @Override
    public void run() {
        System.out.println("新的线程");
        try {
            // 使该线程睡眠100ms
            Thread.sleep(100);  
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

スレッドの優先順位

Javaでは、スレッドの優先度は1と10の間の整数で表されます。優先度の高い、価値が高いです。デフォルトは5です
詳細スレッドを調整するには適していません
5のメインスレッドの優先順位のデフォルト値。親スレッドとして子スレッドの優先順位と同じ初期値。
:(）正確な優先順位を変更することはできません
- 公共の最終無効setPriorityを（int型newPriority）

public class xiancheng2 {
    public static void main(String[] args) {
            
        //创建对象
        Myrun  run1 =  new Myrun(1);
        Myrun  run2 =  new Myrun(2);
        //创建线程对象
        Thread  runTd1 = new Thread( run1 );
        Thread  runTd2 = new Thread( run2 );
        //设置优先级
        runTd2.setPriority( Thread.MIN_PRIORITY );//最高的优先级
        runTd1.setPriority( Thread.MAX_PRIORITY );//最低的优先级
        //开启线程
        
        runTd2.start();
        
        runTd1.start();
        
    }
}
class Myrun implements Runnable{
    private  int id ;
    public Myrun(int id) {
        this.id = id;
    }
    @Override
    public void run() {
        System.out.println("新的线程"+ this.id);
    }
    
}

スレッド譲歩

分類
- ただ、特定のCPUを与えることはできませんが、現在のスレッドのCPUリソースが、（保証）を決定しませんしましょう
- 譲歩に指定されたスレッドを与えるスレッド、指定されたスレッドは、それが実行を再開しません、完了していない（スレッドが合併 - 保証します）
利回り法
- スレッドは現在、バックレディ状態に、CPUを作るために実行されています。（不安）
  - 恥骨の静的な無効収量（）
メソッドに参加

他のスレッドの再開後、メソッドを実行しているスレッドに参加するために呼び出します
- 公共の最終ボイドが例外：InterruptedExceptionを投げる）（参加します
- 公共の最終のボイド（長いミリ秒）に参加例外：InterruptedExceptionを投げます
- 公共の最後のボイドが（長いミリ秒、int型またはnanos）スロー例外：InterruptedExceptionに参加します

public class xiancheng2 {
    public static void main(String[] args) throws InterruptedException{
            
        Thread  run1 =  new Myrun("先");
        Thread  run2 =  new Myrun("后");
        
        run2.start();
        run2.join();    //run2线程将执行完后，在恢复其他线程。
        
        run1.start();
        for (int i = 0; i < 50; i++) {  
            System.out.print(6);
        }
    }
}
class Myrun extends Thread{
    private  String id ;
    public Myrun(String id) {
        this.id = id;
    }
    @Override
    public void run() {
        try {
            
        } catch (Exception e) {
            // TODO: handle exception
        }
        for(int  i=100 ;i>0;i--) {
            System.out.print(this.id);
        }
    }
}

注（パラメータがあります）



如果A线程中掉用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。
需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。                     
                                                                            摘自：https://www.cnblogs.com/ldq2016/p/9045551.html

スレッドガード

バックグラウンドで実行中のスレッドは、（メモリ管理、スレッドのスケジューリング...）と呼ばれるデーモンスレッド

開発デーモンスレッド
- 公共の最終のボイドは、setdaemon（ブールの）//デーモンスレッドを表現するかどうかの（FAL SE：普通のスレッド）
  - Javaで：しかし、フォアグラウンドスレッド（一般的なスレッド）が実行された後、プログラムを終了
    - そして、台湾のプログラムに返さ完全に無関係に実行されます。

スレッド同期

同期方法

同期方法と同期の修飾方法をいいます
- 同期<戻り型>メソッド名（[パラメータリスト]）[スロー例外] {
  
  }
  - 次のように静的ロックオブジェクトの同期方法であって、オブジェクトの現在のクラス
  - ロックオブジェクトの非静的な同期メソッドは次のようになります。これは、
  - スレッドがスリープ状態になるか、ロックロック後に譲歩してロック睡眠一緒に譲歩を得るとき。
  - 同期メソッドが終了した後、ロックはロックを取得することができ、他のスレッドを待って、リリースされています。
  - 同期は、同時実行のマルチスレッドを削減します。

public class tridet {

    public static void main(String[] args) {
        
        Ticket tck = new Ticket();
        Thread t2 = new Thread(tck,"window1");
        Thread t1 = new Thread(tck,"window2");
        Thread t3 = new Thread(tck,"window3");
        System.out.println( "tck: " + tck );
        t1.start();
        t2.start();
        t3.start();
    }
}

class Ticket implements Runnable{
    private  int  TicketNum = 100;
    
    public void run() {
        while( this.TicketNum>0 ) {
            this.buy();
        }
    }
    
    public synchronized void buy() {
        System.out.println( this );  // this ==> tck(锁对象)
        if(this.TicketNum-->0) 
            System.out.println(Thread.currentThread().getName() + "买出一张票，还剩：" + this.TicketNum   );
    }
}

同期スケジューリング方法

最後の空の待機（）	待機状態にスレッドを作成します。別のスレッドの呼び出しは、目を覚ますために通知したりのnotifyAllメソッドまで、
最終無効待機（長いタイムアウト）	スレッドを作るためのタイムアウト（ミリ秒）は、待機時間まで待機状態に入る、またはウェイクアップします。
最後の無効通知（）	プールのために待機しているスレッドを覚ます（保証なしに、目を覚ますていないことを確認これは一つのスレッド）
最後の空のnotifyAll（）	プールで待機しているすべてのスレッドを覚まします

同期ステートメントブロック

同期（ロックオブジェクト）{}

ユニークであるオブジェクトをロック

彼の拘禁中のキーのようなロックオブジェクトは、その後、彼らは（キー文（鍵の返却）他のスレッドの完成同期ブロックは、ステートメントの同期ブロックを入力するだけで一つのスレッドの実行が、したいすべての人が唯一のキーを維持するための同期性を保証を確保するために行う必要があります一つだけ）。

public class tridet {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Thread t2 = new Ticket("window2");
        Thread t1 = new Ticket("window1");
        Thread t3 = new Ticket("window3");
        t1.start();
        t2.start();
        t3.start();
        
    }
}

class Ticket extends Thread{
    private static int  TicketNum = 10;
    private static Object  look = new Object(); // 锁对象（唯一）
    
    public void run() {
        while( this.TicketNum > 0 ) {
            synchronized (look) {
                if(this.TicketNum--<=0) break;
                System.out.println(getName() + "买出一张票，还剩：" + this.TicketNum   );
            }   
        }
    }
    
    public Ticket(String name) {
        super(name);
    }
}


public class tridet {

    public static void main(String[] args) {
        
        Ticket tck = new Ticket();
        
        Thread t2 = new Thread(tck,"window1");
        Thread t1 = new Thread(tck,"window2");
        Thread t3 = new Thread(tck,"window3");
        t1.start();
        t2.start();
        t3.start();
        
    }
}

class Ticket implements Runnable{
    private  int  TicketNum = 100;
    
    public void run() {
        while( this.TicketNum > 0 ) {
            synchronized (this) {   //锁对象为this , 即：tck对象（唯一）
                if(this.TicketNum--<=0) break;
                System.out.println(Thread.currentThread().getName() + "买出一张票，还剩：" + this.TicketNum   );
            }   
        }
    }
}

デッドロック

他のリソースのロックを解除するために、各オブジェクトが待っています。


public class shisuo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Object oj1 = new Object();
        Object oj2 = new Object();
        
        boy b1 = new boy( oj1 , oj2 );
        girl g1 = new girl( oj1 , oj2 );
        
        Thread thread1 = new Thread(b1,"boy");
        Thread thread2 = new Thread(g1,"boy");
        
        thread1.start();
        thread2.start();
    }
}

class boy implements Runnable {
    private Object look1, look2;
    public boy(Object look1, Object look2) {
        super();
        this.look1 = look1;
        this.look2 = look2;
    }
    public void run() {
        synchronized (look1) {
            System.out.println("body");
            synchronized (look2) {
                System.out.println("body2");
            }
        }
    }
}

class girl implements Runnable {
    private Object look1, look2;
    public girl(Object look1, Object look2) {
        super();
        this.look1 = look1;
        this.look2 = look2;
    }
    public void run() {
        synchronized (look2) {
            System.out.println("girl");
            synchronized (look1) {
                System.out.println("girl2");
            }
        }
    }
}

volatileキーワード

役割：プロセスは、そのメンバ変数であるスレッドの動作が変更別のスレッド挿入操作を許可しません。
このキーワードは、ローカル変数のみを変更することはできません、メンバ変数を変更することが許可されています。
- ローカル変数は、同時に2つのスレッドをすることはできません

カスタムスレッド

実装

Threadクラスの継承

Runnableを実装します

違い

スレッド状態

使用糸

眠り

スレッドの優先順位

スレッド譲歩

スレッドガード

スレッド同期

同期方法

同期スケジューリング方法

同期ステートメントブロック

デッドロック

volatileキーワード

おすすめ