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

线程的状态

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

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

/**

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

    * <ul>

    * <li>{@link #NEW}<br>

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

    *    </li>

    * <li>{@link #RUNNABLE}<br>

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

    *    </li>

    * <li>{@link #BLOCKED}<br>

    *    A thread that is blocked waiting for a monitor lock

    *    is in this state.

    *    </li>

    * <li>{@link #WAITING}<br>

    *    A thread that is waiting indefinitely for another thread to

    *    perform a particular action is in this state.

    *    </li>

    * <li>{@link #TIMED_WAITING}<br>

    *    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}<br>

    *    A thread that has exited is in this state.

    *    </li>

    * </ul>

    *

    * <p>

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

        *

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

    }

<li>{@link #NEW}<br>

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

*    </li>

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

* <li>{@link #RUNNABLE}<br>

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

*    </li>

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

* <li>{@link #BLOCKED}<br>

*    A thread that is blocked waiting for a monitor lock

*    is in this state.

*    </li>

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

* <li>{@link #WAITING}<br>

*    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}<br>

*    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}<br>

*    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

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

©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。