线程创建与常用方法介绍
线程创建与常用方法介绍
一、线程创建方式
- 实现Runable接口
- 继承Thread
- 实现Callable接口
实现Runable接口
public interface Runnable {
//抽象的run方法
public abstract void run();
}
实现Runnable接口，实现其提供的run方法
Runnable实现类使用Demo
//Runnable实现类的使用
RunableDemo runable = new RunableDemo();
Thread thread = new Thread(runable, "A");
//子线程的启动需要调用start方法
thread.start();
使用步骤：
1、创建一个Runnable接口的实现类，并实现run（）方法
2、实例化Runnable接口实现类
3、创建Thread类实例，将实例化的Runnable实例作为参数传递
4、启动子线程，调用Thread类的实例的start方法
继承Thread
Thread类的定义：
public class Thread implements Runnable
Thread类也是Runable接口的实现类，实现类run方法
public void run() {
if (target != null) {
target.run();
}
}
继承Thread类时，重写run方法
继承Thread类使用Demo
ThreadDemo threadDemo = new ThreadDemo();
threadDemo.start();
使用步骤：
1、创建类，继承Thread（extends Thread），重写run方法
2、实例化当前创建的Thread类的子类
3、启动子线程，调用start方法
实现Callable接口
Callable接口的什么如下：
public interface Callable<V> {
V call() throws Exception;
}
Callable接口提供了call方法，具有范围值，通过泛型来定义，该接口可以抛出异常
FutureTask类声明：
public class FutureTask<V> implements RunnableFuture<V>
//RunnableFuture接口声明
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
FutureTask类是继承Runable接口，即FutureTask是Runable接口的实现类，而FutureTask类提供了构造函数FutureTask(Callable callable)，可以接受Callable类型的任务
Callable接口的使用Demo：
//实现Callable接口
CallableDemo callableDemo = new CallableDemo();
//通过FutureTask可以将Callable实现类兼容成Runable实现类
FutureTask futureTask = new FutureTask <>(callableDemo);
Thread thread = new Thread(futureTask);
thread.start();
使用步骤：
1、创建类，实现Callable接口，实现其提供的call方法
2、创建Callable实例
3、创建FutureTask实例，将Callable实例作为参数传入
4、创建Thread类实例，将FutureTask实例作为参数传入（当做Runable实例）
5、启动子线程，调用Thread类的start方法
Runable接口和callable接口区别：
1、Callable接口规定的方法是call()方法，Runnable接口规定的方式是run()方法
2、Callable的任务执行后有返回值，而Runable的任务不能有返回值
3、call()方法可抛出异常，run()方法不能抛出异常
4、通过运行Callable的实例可以获取到FutureTask对象，FutureTask对象表示异步执行的结果，他提供了get方法可以异步获取线程执行的结果（get方法会阻塞当前线程）,可以了解子线程的执行情况，可以取消任务的执行
线程状态及状态转换
Java中线程状态由6种
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
NEW：新建状态
用new创建的线程处于新建状态，此时他和其他的Java对象一样，仅仅在堆中分配了内存
Runable：就绪状态
当线程对象被创建后，调用了start方法，线程就处于就绪状态，处于就绪状态的线程（其他的条件都满足，可以等待获取CPU的使用权），等待获取CPU的使用权
Running：运行状态
处于运行状态的线程也就占用的CPU，执行线程代码。只能有就绪状态的线程进入到运行状态
Blocked：阻塞状态
阻塞状态是指线程因为某些原因放弃CPU（缺少资源：IO、锁），暂时停止运行，当前的线程处于阻塞状态
Waiting：等待状态
当线程处于该状态，如果某个线程中的对象的wait()时，JVM就会将线程放入到等待池池
Timed_waiting:超时等待
sleep(long time)，jion(long time) 会使线程处于睡眠状态
Terminated：终止状态
当线程执行到run()方法结尾时，就进入到终止状态，该表示线程的生命周期结束
线程状态转换图
通过线程转换可知：一个线程的生命周期中需要的状态：New、Runable、Running、Terminated四个状态
线程在需要响应的资源时，进入到阻塞状态：阻塞状态包含Waiting，Blocked、Time_waiting状态
线程常用方法介绍
start():启动线程
start方法启动一个新线程，start方法首先调用才能创建子线程，不能重复使用
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
boolean started = false;
try {
start0();
started = true;
} finally {
//省略非核心代码
}
}
private native void start0(); //调用native方法
启动方法是需要底层OS来启动子线程，start是间接启动
native方法说明：
JNI：Java native interface，java本地方法接口（JMM中存在本地方法栈），调度系统本身的提供的非Java代码（C/C++代码）
run():子线程的执行体
整个子线程执行的业务逻辑都在run方法中
单独调用run方法，会在当前的线程中执行run()操作，和普通方法调用是一样的，不会启动子线程，run方法可以重复调用
public void run() {
if (target != null) {
target.run();
}
}
Thread类中的run方法只是判断任务体Runable是否存在，未做其他业务，继承Thread是需要重写
start()和run()方法的区别？
- start()方法是用来启动子线程，start方法启动子线程后自动的来调用run方法
run()方法是子线程的业务执行体，不能直接调用run方法（通过调用run方法是不能操作子线程的） - start()不能重复调用，但是run()可以重复调用
yield():线程让步
是用来暂停当前线程的执行，并且让步于其他相同优先级或更高优先级的线程先执行
yield()：方法在thread类中，是Thread类中静态方法
yield方法特点：
1、yield方法让步CPU的资源，让给谁由系统决定的，一般是让给相同优先级或者更高优先级的线程获得执行权，如果没有的话，会执行原来的线程
2、yield让步：会让当前线程由“运行状态”进入到“就绪状态”，等待CPU的调度
3、yield让步CPU资源后，线程不会释放锁
public static native void yield();
join():线程合并
暂停当前线程执行，等待子线程的执行，也叫做线程合并，join方式是将并行执行的线程合并成串行执行，
例：在线程ta中调用tb.join,会暂停ta的执行，先让tb执行完毕，ta才会执行
方法介绍：
t.join() 允许t线程在当前线程之前执行，待t线程执行结束当前线程在执行
t.join(long millis)（时间单位：毫秒）允许t线程在当前线程之前执行，且最长时间millis毫秒之后，当前线程才能执行
t.join(long millis, int nanos)与t.join(long)一样，只不过可以提供纳秒级的精度
方法特点：
1、join方法是thread类中的方法，会抛出InterruptedException中断异常
2、当前线程ta中tb.join，tb会执行，ta线程会进入WAITING或TIMED_WAITING状态
3、当前线程ta中tb.join，则ta线程会释放当前持有的锁，join方法实现是通过wait/notify线程通信方式来实现的，wait方法的使用会释放锁
//一直等待子线程
public final void join() throws InterruptedException {
join(0);
}
//提供毫秒，纳秒级别的等待时间
public final synchronized void join(long millis, int nanos) throws InterruptedException {
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
//纳秒的处理最终转换为毫秒处理
join(millis);
}
//提供毫秒级别的等待时间
public final synchronized void join(long millis)throws InterruptedException {
if (millis == 0) {
//millis=0，会一直判断子线程是否结束，否则会一直等待
while (isAlive()) {
//线程等待
wait(0);
}
} else {
//判断子线程是否结束且是否到达指定的毫秒数，否则会等待
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
}
}
}
eg：假如存在A、B、C三个线程，让三个线程按照C、B、A的顺序执行
package joinTestDemo;
class Thread1 extends Thread{
public void run(){
System.out.println("Threada");
}
}
class Thread2 extends Thread{
public void run(){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Threadb");
}
}
class Thread3 extends Thread{
public void run(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Threadc");
}
}
public class AbcSort {
public static void main(String[] args) throws InterruptedException {
Thread3 thread3=new Thread3();
thread3.start();
thread3.join();
Thread2 thread2=new Thread2();
thread2.start();
thread2.join();
Thread1 thread1=new Thread1();
thread1.start();
}
}
interrupt():中断线程
用来中断当前线程，终止处于“阻塞状态”的线程
方法介绍：
interrupt()：该方法在Thread类中，是一个普通方法，由对象调用该方法
boolean isInterrupted() 判断是否发送了中断操作， true：发生中断操作 false:未发生中断操作
方法特点：
1、如果当前线程是可中断的阻塞状态（join、sleep、wait等方法会导致线程进入阻塞撞状态：WATING / TIMED_WAITING状态），在任意其他的线程中调用interruprt方法，那么会立即抛出抛出InterruptedException来停止的阻塞状态
2、如果当前线程是可运行状态。调用interruprt方法，线程还是会继续执行，直到发生了sleep、join、wait等方法的调用，才会在进入阻塞之后，随后立即抛出InterruptedException，跳出阻塞状态
public void interrupt() {
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag 注意这句
b.interrupt(this);
return;
}
}
interrupt0();
}
private native void interrupt0(); //JNI方法，中断操作由系统来提供中断的方式
sleep():线程休眠
会让线程休眠，而且那个线程调用，那个线程休眠 ，TimeUtil.sleep(long),Threrd.sleep、或当前的额线程t.sleep，其结果都是当前的线程休眠
方法介绍：
sleep(long millis)
sleep(long millis, int nanos)
都是提供休眠操作，时间单位粒度不同
sleep 是Thread类提供的方法，会抛出InterruptedException异常
方法特点：
1、sleep休眠期间，会让出CPU使用权，但线程任然持有锁
2、sleep休眠时间到了之后，不会立即执行，而是线程由“阻塞状态”进入到“就绪状态”
public static native void sleep(long millis) throws InterruptedException //JNI
public static void sleep(long millis, int nanos) throws InterruptedException {
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
sleep(millis);
}
deamon:守护线程
方法介绍：
setDaemon(boolean on) 设置线程为守护线程 true:表示是守护线程 false：非守护线程 默认false
boolean isDaemon()：判断当前线程是否是守护线程 true：守护线程
Java中的线程主要有两种：用户线程和守护线程
守护线程和用户线程是什么?
用户线程一般用户执行的用户级的线程
守护线程:也叫做后台线程，脱离于终端，用来服务于用户线程 例如：GC是一个单独的线程来处理，GC线程就是一个守护线程
守护线程的生命周期？
守护线程的生命周期是依赖于用户线程，当有用户线程存在，守护线程就会存活，当没有用户线程存在，那守护线程也随之消亡，
需要注意的是：Java虚拟机在“用户线程”都结束后会后退出。
public final void setDaemon(boolean on) {
checkAccess();
if (isAlive()) {
throw new IllegalThreadStateException();
}
daemon = on;
}
public final boolean isDaemon() {
return daemon;
}
Priority：线程的优先级
线程优先级，顾名思义：就是来指导线程的执行优先级的
方法介绍：
int getPriority() 获取优先级
setPriority(int newPriority) 设置优先级
方法特点：
1、java线程的优先级并不绝对，它所控制的是执行的机会，也就是说，优先级高的线程执行的概率比较大，而优先级低的线程也并不是没有机会，只是执行的概率相对低一些。
2、Java线程一共有10个优先级，分别为1-10，数值越大，表明优先级越高，一个普通的线程，其优先级为5；
线程的优先级具有继承性，如果一个线程B是在另一个线程A中创建的，则B叫做A的子线程，B的初始优先级与A保持一致。
优先级范围：
public final static int MIN_PRIORITY = 1; //最小优先级
public final static int NORM_PRIORITY = 5; //默认优先级
public final static int MAX_PRIORITY = 10; //最大优先级
java 中的线程优先级的范围是1～10.最小值是1,默认的优先级是5,最大值是10.“高优先级线程”会优先于“低优先级线程”执行
public final int getPriority() {
return priority;
}
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority);
}
}
private native void setPriority0(int newPriority); //JNI