线程

在这里插入图片描述

图片来自网络

线程状态可以通过线程对象.getState()方法获取，是枚举类型。以下是JDK1.8的线程状态源码

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

简单的一个线程Thread和Runnable的代码

public class ThreadDemo1 {
	public static void main(String[] args) {
		Runnable r = () -> System.out.println(Thread.currentThread().getName() + "的业务逻辑部分");
		Thread t1 = new Thread(r, "1号线程");
		Thread t2 = new Thread(r);
		Thread3 t3 = new Thread3();
		t3.setName("3号线程");
		System.out.println(t3.getState());
		t1.start();
		t2.start();
		t3.start();
		System.out.println(t3.getState());
	}
}

class Thread3 extends Thread {
	public Thread3() {
		System.out.println("创建线程3");
	}
	
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "的业务逻辑部分");
	}
}

这里有多条线程并发执行，运行结果有很多种，以下是一种

创建线程3
NEW
1号线程的业务逻辑部分
Thread-0的业务逻辑部分
RUNNABLE
3号线程的业务逻辑部

NEW(创建状态): Thread t1 = new Thread(r, “1号线程”); 即创建了一个线程。进入NEW状态。

new关键字仅为创建一个线程类，在没有调用start()方法前，它就是一个普通的java类。
RUNABLE(运行状态): t1.start() 调用start()方法，线程即进入就绪状态。处于就绪状态的线程，随时等待cpu调度执行，变为RUNNING状态。

当执行start()方法后，才会在jvm中创建线程，此时线程等待cpu调度运行。Java将就绪状态和运行状态合称为运行状态。其实RUNNABLE是翻译为就绪的。由源码也可以看到，只有RUNNABLE没有RUNNING。内部可以细分为这两个
BLOCKED(阻塞状态): 处于运行状态的线程，由于原因，暂时放弃对cpu的使用权，停止执行，此时进入阻塞状态，直到进入就绪状态。
WAITING(等待): 处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
TIMED_WAITING(超时等待): 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
TERMINATED(终止状态): 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

Thread和Runnable

线程流程：

当线程创建后，调用start()方法启动线程。start()方法会调用本地方法栈(JNI)中方法start()。然后由其调用线程的run()方法。run()方法也就是线程体，run()方法运行结束了，线程也就终结了。调用线程的start()方法的时候，提到过线程只是就绪，还没有运行。这也是多线程的实现。

Thread的run和start方法是使用模板模式设计的。

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

Runnable的策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

由于多个线程所实现的run方法控制具体逻辑，每次创建线程的时候都需要隐式创建该方法，故此java提供一个接口Runnable来将线程的控制和业务逻辑分离开。创建线程只有一种方式，即构造Thread类，而实现现成的执行单元有两种方式，第一种是重写Thread的run方法，第二种是实现Runnable接口的run方法，并将Runable接口实例用作构造Thread的参数。
策略模式的目的是将线程的控制本身和业务逻辑的运行分离开，达到职责分明，功能单一的原则

Thread类的run方法不能共享，而实现Runnable的实例则可以构造不同的Thread实例。

Java线程Thread和Runable

线程

Thread和Runnable

线程流程：

Thread的run和start方法是使用模板模式设计的。

Runnable的策略模式

参考

猜你喜欢