java线程就绪方法_Java基础之Java线程

1. 线程定义

线程(英语：thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程 (lightweight processes)，但轻量进程更多指内核线程(kernel thread)，而把用户线程 (user thread)称为线程。

线程是独立调度和分派的基本单位。线程可以操作系统内核调度的内核线程，如Win32线程； 由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如 Windows 7的线程，进行混合调度。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信 号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境 (register context)，自己的线程本地存储(thread-local storage)。

一个进程可以有很多线程，每条线程并行执行不同的任务。

2. 线程实现

Java中的线程都是调用的原生系统的本地函数，Java线程模型是基于操作系统原生线程模型实现的，实现线程有三种方式：内核线程实现、用户线程实现、混合线程实现。

2.1 内核线程实现

直接由操作系统内核支持的线程，通过内核来完成进程切换。每个内核线程就是一个内核的 分身，这样操作系统就可以同时处理多件事情，支持多线程的内核被称为多线程内核。

程序一般不直接使用内核线程，而是使用一种高级接口——轻量级进程，轻量级进程就是我 们通常意义上的线程，可以获得内核线程的支持，与内核线程构成 1:1 的线程模型。

2.2 用户线程实现

从广义上说，一个线程不是内核线程，就是用户线程，所以轻量级进程也属于用户线程。狭 义的用户线程是指完全建立在用户空间上的，系统内核不能感知到其存在。

用户线程的创建、同步、销毁和调度都是在用户空间实现的，因此相对较快，代价相对较 低。这种用户线程和进程是 N:1 的线程模型

2.3 混合实现

这种实现模式将内核线程与用户线程一起使用，在这种方式下既存在用户线程，也存在轻量 级进程。用户线程还是完全建立在用户空间，因此用户线程的创建、切换等操作依旧低廉。 而操作系统提供的轻量级进程则作为用户线程和内核线程的桥梁，这样就可以使用内核提供 的线程调度及处理器映射。这种实现下，用户线程和轻量级进程是 M:N 的模式。

3. 线程调度

线程调度分为协同式和抢占式。

协同式调度：线程的执行时间由线程自己控制，这种的实现很简单，但是很可能造成很严 重的后果。

抢占式调度：由操作系统分配线程执行的时间，线程切换的决定权在操作系统。

有时候我们需要为某些线程多分配时间，这时我们就需要用到线程优先级的方法，Java提供 了10种优先级。Java优先级是在操作系统的原生线程优先级上实现的，所以对于同一个优先 级，不同的操作系统可能有不同的表现，也就是说 Java线程优先级不是可靠的。

4. 线程的状态

新建状态:使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:如果一个线程执行了sleep(睡眠)、suspend(挂起)等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

5. 线程的优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是 1 (Thread.MIN_PRIORITY ) – 10 (Thread.MAX_PRIORITY )。

默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY(5)。

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

6. Thread 方法

下表列出了Thread类的一些重要方法：

序号

方法描述

1

public void start()

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

2

public void run()

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

3

public final void setName(String name)

改变线程名称，使之与参数 name 相同。

4

public final void setPriority(int priority)

更改线程的优先级。

5

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。

6

public final void join(long millisec)

等待该线程终止的时间最长为 millis 毫秒。

7

public void interrupt()

中断线程。

8

public final boolean isAlive()

测试线程是否处于活动状态。

下面的方法是Thread类的静态方法。

序号

方法描述

1

public static void yield()

暂停当前正在执行的线程对象，并执行其他线程。

2

public static void sleep(long millisec)

在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)，此操作受到系统计时器和调度程序精度和准确性的影响。

3

public static boolean holdsLock(Object x)

当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。

4

public static Thread currentThread()

返回对当前正在执行的线程对象的引用。

5

public static void dumpStack()

将当前线程的堆栈跟踪打印至标准错误流。

7. 创建线程的方法

Java 提供了三种创建线程的方法：

通过实现 Runnable 接口；

通过继承 Thread 类本身；

通过 Callable 和 Future 创建线程。

8. 创建线程的三种方式的对比

1. 采用实现 Runnable、Callable 接口的方式创见多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

3.Callable接口的线程执行体是call()，而Runnable接口的线程执行体是run() ，call()方法可以有返回值，也可以抛出异常。可以把Callable接口看做Runnable接口的增强版。

9.  举例

public class Test {

public static class MyThread extends Thread{

@Override

public void run() {

super.run();

System.out.println(MyThread.class.getSimpleName());

}

}

public static class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println(MyRunnable.class.getSimpleName());

}

}

public static class MyCallable implements Callable {

private String taskNum;

public MyCallable(String taskNum) {

this.taskNum = taskNum;

}

public Object call() throws Exception {

System.out.print(MyCallable.class.getSimpleName());

System.out.println(">>>" + taskNum + "任务启动");

Date dateTmp1 = new Date();

Thread.sleep(1000);

Date dateTmp2 = new Date();

long time = dateTmp2.getTime() - dateTmp1.getTime();

System.out.println(">>>" + taskNum + "任务终止");

return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";

}

}

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

//Thread

new MyThread().start();

//Runnable

new Thread(new MyRunnable()).start();

//Future

System.out.println("----Test Running----");

Date date1 = new Date();

int taskSize = 5;

ExecutorService pool = Executors.newFixedThreadPool(taskSize);

List list = new ArrayList<>();

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

Callable c = new MyCallable(i + "");

Future f = pool.submit(c);

list.add(f);

}

// 关闭线程池

pool.shutdown();

// 获取所有并发任务的运行结果

for (Future f : list) {

// 从Future对象上获取任务的返回值，并输出到控制台

System.out.println(">>>" + f.get().toString());

}

Date date2 = new Date();

System.out.println("----程序结束运行----，程序运行时间【" + (date2.getTime() - date1.getTime()) + "毫秒】");

}

}

public class Test {

public static class MyThread extends Thread{

@Override

public void run() {

super.run();

System.out.println(MyThread.class.getSimpleName());

}

}

public static class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println(MyRunnable.class.getSimpleName());

}

}

public static class MyCallable implements Callable {

private String taskNum;

public MyCallable(String taskNum) {

this.taskNum = taskNum;

}

public Object call() throws Exception {

System.out.print(MyCallable.class.getSimpleName());

System.out.println(">>>" + taskNum + "任务启动");

Date dateTmp1 = new Date();

Thread.sleep(1000);

Date dateTmp2 = new Date();

long time = dateTmp2.getTime() - dateTmp1.getTime();

System.out.println(">>>" + taskNum + "任务终止");

return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";

}

}

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

//Thread

new MyThread().start();

//Runnable

new Thread(new MyRunnable()).start();

//Future

System.out.println("----Test Running----");

Date date1 = new Date();

int taskSize = 5;

ExecutorService pool = Executors.newFixedThreadPool(taskSize);

List list = new ArrayList<>();

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

Callable c = new MyCallable(i + "");

Future f = pool.submit(c);

list.add(f);

}

// 关闭线程池

pool.shutdown();

// 获取所有并发任务的运行结果

for (Future f : list) {

// 从Future对象上获取任务的返回值，并输出到控制台

System.out.println(">>>" + f.get().toString());

}

Date date2 = new Date();

System.out.println("----程序结束运行----，程序运行时间【" + (date2.getTime() - date1.getTime()) + "毫秒】");

}

}

运行结果：