Java基盤_デッドロック、スレッドグループ、タイマーのタイマー

まず、デッドロック：

　　デッドロックが状況です：複数のスレッドがブロックされ、そのうちの一つまたはすべてが解放されるリソースを待っています。スレッドが無期限にブロックされているので、そのプログラムが正常に終了することはできません。

　　例えば、最初のスレッドがロックがアイドル状態である必要性、特定のスレッド、必要な2つの第二のスレッドである、第2のロックがアイドル状態である、二つのスレッドには、これは問題ありません。

　　最初のスレッドが返されていない第二の二必要にスレッドを置く必要があるときしかし、彼らは、あなたはまだ2スレッドする必要があるかもしれませ復帰への2つのロックを待機する必要がありますスレッドをスレッド、その後、第2のロックをスレッドする必要があります待機状態でも、ロックをスレッド、したがって、糸と糸ループ待機2が残って、両方のスレッドは、物事は、両方のデッドロック状態を成し遂げるためにロックを返却することはできません。。。

パッケージcom.Gary1を。

パブリック クラスデッドロック{ 

    パブリック 静的オブジェクトLOCK1 = 新しいオブジェクト（）;
    パブリック 静的のオブジェクトLOCK2 = 新しいオブジェクト（）; 
    
    
    パブリック 静的 ボイドメイン（文字列[]引数）{ 
        
        新しいスレッド（新しいスレッド1（））（開始）。
        新しいスレッド（新しいスレッド2（））（開始）。
        
    } 
    
} 

クラススレッド1 を実装したRunnable { 

    @Override 
    公共 ボイドラン（）{
         同期（DeadLock.lock1）{ 
            System.out.printlnは（「最初のロックは、物事をした後に行うには」）;
             試み{
                 //が100ミリ秒を要し、何かをし続ける 
                のThread.sleep（百を）; 
            } キャッチ（InterruptedExceptionありますE）{ 
                e.printStackTrace（）; 
            } 
            同期（DeadLock.lock2）{ 
                System.out.printlnは（ "2つのロックを達成しながら、以下のものをスレッド1を行う" ）; 
            } 
        } 
        
    } 
} 

クラススレッド2 実装のRunnable { 

    @Override 
    公衆 空隙RUN（）{
         同期（DeadLock.lock2）{ 
            System.out.printlnは（「第2のロックは、物事をした後に行うには」）;
             試み{
                 //は100ミリ秒を要し、何かをし続ける 
                のThread.sleep（百を） ; 
            } キャッチ（InterruptedExceptionあるE）{ 
                e.printStackTrace（）; 
            } 
            同期（DeadLock.lock1）{ 
                するSystem.out.println（ "行う以下の事スレッド2 2つのロックを達成しながら" ）; 
            } 
        } 
        
        
    } 
}

DeadLock.java

　　解決順序ロック：このような状況を回避する最善の方法

　　オーダーの両側にねじロックlock1-> LOCK2

package com.Gary1;

public class DeadLock {

    public static Object lock1 = new Object();
    public static Object lock2 = new Object();
    
    
    public static void main(String[] args) {
        
        new Thread(new Thread1()).start();
        new Thread(new Thread2()).start();
        
    }
    
}

class Thread1 implements Runnable{

    @Override
    public void run() {
        synchronized(DeadLock.lock1) {
            System.out.println("取得第一把锁之后要做的事情");
            try {
                //耗时100毫秒，继续做一些事情
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(DeadLock.lock2) {
                System.out.println("Thread1同时取得两把锁之后要做的事情");
            }
        }
        
    }
}

class Thread2 implements Runnable{

    @Override
    public void run() {
        synchronized(DeadLock.lock1) {
            System.out.println("取得第二把锁之后要做的事情");
            try {
                //耗时100毫秒，继续做一些事情
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(DeadLock.lock2) {
                System.out.println("Thread2同时取得两把锁之后要做的事情");
            }
        }
        
        
    }
}

DeadLock.java

二、线程组ThreadGroup 默认处于同一个组里面

　　　　使用线程组可以统一设置这个组内线程的一些东西。比如设置优先级，设置是否是守护线程

    ThreadGroup tg = new ThreadGroup("我们的线程组");
        
    Thread t1 = new Thread(tg,r);
    Thread t2 = new Thread(tg,r);
        
    //批量管理
    tg.interrupt();//中断里边所有线程
    tg.setDaemon(true);//设置守护线程
    tg.setMaxPriority(9);//设置线程组最大优先级

package com.Gary1;

public class ThreadGroupDemo {

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        
        ThreadGroup tg = new ThreadGroup("我们的线程组");
        
        Thread t1 = new Thread(tg,r);
        Thread t2 = new Thread(tg,r);
        
        //批量管理
        tg.interrupt();//中断里边所有线程
        tg.setDaemon(true);//设置守护线程
        tg.setMaxPriority(9);//设置线程组最大优先级
        
        //ThreadGroup tg = t1.getThreadGroup();
        //输出线程名字
        //System.out.println(tg.getName());
        //输出线程组名字
        //System.out.println(t2.getThreadGroup().getName());
        
        t1.start();
        t2.start();
        
    }
    
}

ThreadGroupDemo.java

package com.Gary1;

public class MyRunnable implements Runnable{

    private String data = "";
    
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName()+":"+i);
        }
        
    }

}

MyRunnable.java

三、定时器Timer

　　作用：一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。

　　使用类：Timer和TimerTask

　　常用方法：

　　　　timer.schedule(TimerTask task, long delay) 　　

　　　　timer.schedule(TimerTask task, long delay, long period)

　　　　timer.schedule(TimerTask task, Date time)

　　　　timer.cancel();

public static void main(String[] args) {
        //Timer TimerTask
        Timer t = new Timer();
        
        //定义一个定时器任务，2000毫秒开始执行
        //t.schedule(new MyTimerTask(), 2000);
        //定义一个定时器任务，2000毫秒开始执行，每个3000毫秒执行一次
        //t.schedule(new MyTimerTask(), 2000，3000);
        //在哪个时间开始执行这个任务
        //t.schedule(new MyTimerTask(), time);
        //终止定时器任务执行
        //timer.cancel();
    }

package com.Gary1;

import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo {
    public static void main(String[] args) {
        //Timer TimerTask
        Timer t = new Timer();
        
        //定义一个定时器任务，2000毫秒开始执行
        //t.schedule(new MyTimerTask(), 2000);
        //定义一个定时器任务，2000毫秒开始执行，每个3000毫秒执行一次
        //t.schedule(new MyTimerTask(), 2000，3000);
        //在哪个时间开始执行这个任务
        //t.schedule(new MyTimerTask(), time);
        //终止定时器任务执行
        //timer.cancel();
    }

}

class MyTimerTask extends TimerTask{

    @Override
    public void run() {
        System.out.println("定时器任务");
        
    }
    
}

TimerDemo.java

Java基盤_デッドロック、スレッドグループ、タイマーのタイマー

おすすめ