《Java多线程编程核心技术》读后感（十五）

线程的状态

线程对象在不同的运行时期有不同的状态，状态信息就存在与State枚举类中。

验证New,Runnable，Terminated

new:线程实例化后还从未执行start()方法时的状态

runnable：线程进入运行的状态

terminated：线程被销毁时的状态

package Seven;

public class MyThread extends Thread {

    public MyThread() {
        System.out.println("构造方法中的状态：" + Thread.currentThread().getState());
    }

    @Override
    public void run() {
        System.out.println("run方法中的状态：" + Thread.currentThread().getState());
    }
}

package Seven;

public class Run {

    // NEW,
    // RUNNABLE,
    // TERMINATED,

    // BLOCKED,
    // WAITING,
    // TIMED_WAITING,

    public static void main(String[] args) {
        try {
            MyThread t = new MyThread();
            System.out.println("main方法中的状态1：" + t.getState());
            Thread.sleep(1000);
            t.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态2：" + t.getState());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

注意：构造方法中的日志时main主线程的

验证Time_waiting

Time_waiting：线程执行了Thread.sleep（）

package Seven;

public class MyThread extends Thread {

    @Override
    public void run() {
        try {
            System.out.println("begin sleep");
            Thread.sleep(10000);
            System.out.println("  end sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package Seven;

public class Run {
    // NEW,
    // RUNNABLE,
    // TERMINATED,

    // BLOCKED,
    // WAITING,
    // TIMED_WAITING,

    public static void main(String[] args) {
        try {
            MyThread t = new MyThread();
            t.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态：" + t.getState());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

验证Blocked

blocked:出现在某一个线程等待锁的时候

package Seven;

public class MyService {
    synchronized static public void serviceMethod() {
        try {
            System.out.println(Thread.currentThread().getName() + "进入了业务方法！");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package Seven;

public class MyThread1 extends Thread {

    @Override
    public void run() {
        MyService.serviceMethod();
    }

}

package Seven;

public class MyThread2 extends Thread {

    @Override
    public void run() {
        MyService.serviceMethod();
    }

}

package Seven;

public class Run {
    // NEW,
    // RUNNABLE,
    // TERMINATED,
    // BLOCKED,
    // WAITING,
    // TIMED_WAITING,

    public static void main(String[] args) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        t1.setName("a");
        t1.start();
        MyThread2 t2 = new MyThread2();
        t2.setName("b");
        t2.start();
        //Thread.sleep(1000);
        System.out.println("main方法中的t2状态：" + t2.getState());

    }
}

验证waiting

waiting：是线程执行了object.wait()方法后所处的状态

package Seven;

public class Lock {

    public static final Byte lock = new Byte("0");

}

package Seven;

public class MyThread extends Thread {

    @Override
    public void run() {
        try {
            synchronized (Lock.lock) {
                Lock.lock.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package Seven;

public class Run {
    // NEW,
    // RUNNABLE,
    // TERMINATED,
    // BLOCKED,
    // WAITING,
    // TIMED_WAITING,

    public static void main(String[] args) {
        try {
            MyThread t = new MyThread();
            t.start();
            Thread.sleep(1000);
            System.out.println("main方法中的t状态：" + t.getState());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}