线程的状态

在进行多线程编程之前，要先知道线程都有哪几种状态。

线程的状态在 java.lang.Thread.State 有定义：

/**

* A thread state. A thread can be in one of the following states:

* <ul>

* <li>{@link #NEW}

* A thread that has not yet started is in this state.

* </li>

* <li>{@link #RUNNABLE}

* A thread executing in the Java virtual machine is in this state.

* </li>

* <li>{@link #BLOCKED}

* A thread that is blocked waiting for a monitor lock

* is in this state.

* </li>

* <li>{@link #WAITING}

* A thread that is waiting indefinitely for another thread to

* perform a particular action is in this state.

* </li>

* <li>{@link #TIMED_WAITING}

* A thread that is waiting for another thread to perform an action

* for up to a specified waiting time is in this state.

* </li>

* <li>{@link #TERMINATED}

* A thread that has exited is in this state.

* </li>

* </ul>

*

* A thread can be in only one state at a given point in time.

* These states are virtual machine states which do not reflect

* any operating system thread states.

* @since 1.5

* @see #getState

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>

* 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;

}

<li>{@link #NEW}

* A thread that has not yet started is in this state.

* </li>

创建后尚未启动的线程处于这种状态

* <li>{@link #RUNNABLE}

* A thread executing in the Java virtual machine is in this state.

* </li>

Runable包括了操作系统线程状态的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。

* <li>{@link #BLOCKED}

* A thread that is blocked waiting for a monitor lock

* is in this state.

* </li>

线程被阻塞了，“阻塞状态”与”等待状态“的区别是：”阻塞状态“在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。

* <li>{@link #WAITING}

* A thread that is waiting indefinitely for another thread to

* perform a particular action is in this state.

* </li>

处于这种状态的线程不会被分配CPU执行时间。

等待状态又分为无限期等待和有限期等待，WAITING 为无限期等待

处于无限期等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；

线程处于WAITING状态的场景。

调用Object对象的wait方法，但没有指定超时值。

调用Thread对象的join方法，但没有指定超时值。

调用LockSupport对象的park方法。

* <li>{@link #TIMED_WAITING}

* A thread that is waiting for another thread to perform an action

* for up to a specified waiting time is in this state.

* </li>

当处于一个给定的等待时间时候，线程处于这种状态 TIMED_WAITING

有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

线程处于TIMED_WAITING状态的场景。

调用Thread.sleep方法。

调用Object对象的wait方法，指定超时值。

调用Thread对象的join方法，指定超时值。

调用LockSupport对象的parkNanos方法。

调用LockSupport对象的parkUntil方法。

* <li>{@link #TERMINATED}

* A thread that has exited is in this state.

* </li>

已终止线程的线程状态，线程已经结束执行。

线程状态间的切换

既然有那么多的线程状态，它们之间的状态转换如下图所示

线程间同步的方法

线程有4中同步方法，分别为wait()、sleep()、notify()和notifyAll()。

wait()：使线程处于一种等待状态，释放所持有的对象锁。

sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。

notify()：唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。

notifyAll()：唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争。

Java 创建线程的4种方式：

继承Thread类创建多线程

实现Runnable接口创建多线程

实现Callable接口通过FutureTask包装器来创建Thread多线程

使用ExecutorService、Callable、Future实现有返回结果的线程。

继承Thread类创建多线程

代码如下：继承Thread类

package com.dazhi.thread.multithread;

/**

* 多线程创建,继承

* @author dazhi

public class MyThread extends Thread{

@Override

public void run() {

for (int i=0; i<10; i++) {

System.out.println(Thread.currentThread().getName() +":"+ i);

}

public static void main(String[] args) throws InterruptedException {

MyThread thread1 = new MyThread();

MyThread thread2 = new MyThread();

MyThread thread3 = new MyThread();

thread1.start();

thread2.start();

thread3.start();

}

实现Runnable接口创建多线程

实现Runnable接口

package com.dazhi.thread.multithread;

/**

* 多线程创建, 实现Runnable

* @author dazhi

public class MyRunnable implements Runnable {

@Override

public void run() {

for (int i=0; i<10; i++) {

System.out.println(Thread.currentThread().getName() +":"+ i);

}

public static void main(String[] args) {

MyRunnable myRunnable = new MyRunnable();

Thread thread1 = new Thread(myRunnable, "thread1");

Thread thread2 = new Thread(myRunnable, "thread2");

Thread thread3 = new Thread(myRunnable, "thread3");

thread1.start();

thread2.start();

thread3.start();

}

实现Callable接口通过FutureTask包装器来创建Thread多线程

实现Callable

package thread.multi;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

/**

* Created by szh on 2020/6/15.

* @author szh

public class CallableThread implements Callable<String> {

@Override

public String call() throws Exception {

Thread.sleep(10 * 1000);

return "Just do it";

}

public static void main(String[] args) throws Exception {

CallableThread callableThread = new CallableThread();

FutureTask<String> stringFuture = new FutureTask<String>(callableThread);

Thread a = new Thread(stringFuture);

a.start();

System.out.println(stringFuture.get());

}

// 运行结果

Just do it

注意 get 会阻塞线程的运行，直到得到返回结果！！

使用ExecutorService、Callable、Future实现有返回结果的线程。

package com.dazhi.thread.multithread;

import java.util.concurrent.*;

/**

* 多线程创建, ExecutorService + Callable + Future

* @author dazhi

public class MyExecutors {

public static void main(String[] args) throws ExecutionException, InterruptedException {

// 不提倡的方式创建线程池方式。为了方便就这样写了

ExecutorService executorService = Executors.newFixedThreadPool(5);

Future<Integer> submit = executorService.submit(new Callable<Integer>() {

@Override

public Integer call() throws Exception {

return 1234;

}

});

executorService.shutdown();

System.out.println(submit.get());

}

// 运行结果

1234

Process finished with exit code 0

// 不提倡创建线程池的原因

Java创建多线程的4种方式与线程状态

Java创建多线程的4种方式与线程状态

线程的状态

线程间同步的方法

Java 创建线程的4种方式：

继承Thread类创建多线程

Java创建多线程的4种方式 与 线程状态

线程的状态

线程间同步的方法

Java 创建线程的4种方式 ：

继承Thread类创建多线程

Java创建多线程的4种方式与线程状态

Java 创建线程的4种方式：