Java多线程编程

Java给多线程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每一条线程并行执行不同的任务。

一个线程的生命周期

线程是一个动态执行过程，他也有一个从生产到死亡的过程
如下图所示：

• 新建状态
  使用new关键字和Thread类或者其子类建立一个线程对象之后，该线程对象就处于新建状态，这个状态就保持到使用start()这个线程
• 就绪状态
  当线程对象调用了start()方法之后，就可以进入就绪状态，就绪状态的线程处于就绪队列中，需要等待jvm里面线程调度器的调用
• 运行状态
  如果就绪状态的线程获取CPU资源，就可以执行run方法，此时的线程就处于运行状态
• 阻塞状态
  如果说一个线程执行了sleep（睡眠）suspend（挂起）等方法，失去所占资源之后该线程就从运行状态进入阻塞状态。在睡眠时间以获得或者得到设备资源之后重新进入就绪状态。可以分为三种。
  1. 等待阻塞：运行状态中的线程执行wait()方法，使线程进入到等待状态。
  2. 同步阻塞：线程在获取synchronized同步锁失败（因为同步锁被其他线程占用）
  3. 其他阻塞：通过调用线程的生sleep（）或者join（）发出了I/O请求时，线程就会进入到阻塞张状态，当sleep装态超时，join等待线程终止或超时，或者I/O处理完毕，线程重新转入就绪状态
• 死亡状态
  一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态

线程的优先级

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

创建一个线程

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

• 通过实现Runnable
• 通过继承Thread类本身
• 通过Callable和Future

通过实现Runnable接口来创建线程

创建一个简单的线程，最简单的方法是创建一个实现Runnable接口的类
为了实现Runnable，一个类只需要执行一个方法调用run()，声明如下：

$实例$

package thread;


/**
 * Created by jdx on 2021/12/20 下午4:46
 */
public class runMethod implements Runnable {
    //定义一个线程
    private Thread thread;
    //定义线程名称
    private String threadName;

    public runMethod(String threadName) {
        this.threadName = threadName;
        System.out.println("创建线程：" + threadName);
    }

    /**
     * @return void
     * @description 重写run方法
     * @author create by JDX
     * @date 2021/12/21 下午4:54
     */
    @Override
    public void run() {
        System.out.println("正在运行的线程：" + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                //线程休眠
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread:" + threadName + "interrupted.");
        }
        System.out.println("Thread:" + threadName + "exiting.");
    }

    /**
     * @return void
     * @description 调用start方法
     * @author create by JDX
     * @date 2021/12/21 下午4:58
     */
    public void start() {
        System.out.println("Staring: " + threadName);
        if (thread == null) {
            thread = new Thread(this, threadName);
            thread.start();
        }
    }
}

接下来我们接着编写一个测试类

package basics;

import thread.runMethod;

/**
 * Created by jdx on 2021/12/21 下午5:01
 */
public class runTest {
    public static void main(String[] args) {
        runMethod method01 = new runMethod("Thread-1");
        method01.start();

        runMethod method02 = new runMethod("Thread-2");
        method02.start();

    }
}

运行结果为：

创建线程：Thread-1
Staring: Thread-1
创建线程：Thread-2
Staring: Thread-2
正在运行的线程：Thread-1
Thread: Thread-1, 4
正在运行的线程：Thread-2
Thread: Thread-2, 4
Thread: Thread-2, 3
Thread: Thread-1, 3
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-2, 1
Thread: Thread-1, 1
Thread:Thread-2exiting.
Thread:Thread-1exiting.

通过继承Thread来创建线程

创建一个线程的第二种方法就是创建一个新的类，该类继承Thread类，然后创建一个该类的实例
继承类必须重写run()方法，该方法是新线程的入口点，他也必须调用start()方法才可以执行
该方法尽管被列为一种或者多线程的实现方式，但是本质上面也是实现了Runnable接口的一个实例

如果说有需要可以观看以下代码，对比他们之间的不同

package thread;

/**
 * Created by jdx on 2021/12/21 下午5:33
 */
public class threadMethod extends Thread{
    //定义一个线程
    private Thread thread;
    //定义线程名称
    private String threadName;

    public threadMethod(String threadName) {
        this.threadName = threadName;
        System.out.println("创建线程：" + threadName);
    }

    /**
     * @return void
     * @description 重写run方法
     * @author create by JDX
     * @date 2021/12/21 下午4:54
     */
    public void run() {
        System.out.println("正在运行的线程：" + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                //线程休眠
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread:" + threadName + "interrupted.");
        }
        System.out.println("Thread:" + threadName + "exiting.");
    }

    /**
     * @return void
     * @description 调用start方法
     * @author create by JDX
     * @date 2021/12/21 下午4:58
     */
    public void start() {
        System.out.println("Staring: " + threadName);
        if (thread == null) {
            thread = new Thread(this, threadName);
            thread.start();
        }
    }
}

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()**测试线程是否处于活动状态。

还有一写静态的方法：

序号	方法描述
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()**将当前线程的堆栈跟踪打印至标准错误流。

通过 Callable 和 Future 创建线程

• 创建callable接口的视线类，并实现call()方法，该方法将作为线程执行体，并且有返回值
• 创建Callable实现类的实例，使用FutureTask来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值
• 使用FutureTask对象作为Thread对象的target创建并启动新线程
• 调用FutureTask对象的get()方法来获得子线程执行结束之后的返回值

$实例$

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Created by jdx on 2021/12/24 下午3:33
 */
public class callAbleThread implements Callable<Integer> {
    public static void main(String[] args) {
        //创建一个新的callAbleThread线程
        callAbleThread callAbleThread = new callAbleThread();
        //创建一个新的FutureTask
        FutureTask<Integer> ft = new FutureTask<Integer>(callAbleThread);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 20) {
                new Thread(ft, "有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值：" + ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }


    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
}

运行结果如下：

main 的循环变量i的值6
main 的循环变量i的值7
main 的循环变量i的值8
main 的循环变量i的值9
main 的循环变量i的值10
main 的循环变量i的值11
main 的循环变量i的值12
·····
main 的循环变量i的值27
main 的循环变量i的值28
有返回值的线程 0
main 的循环变量i的值29
有返回值的线程 1
有返回值的线程 2
有返回值的线程 3
有返回值的线程 4
有返回值的线程 5
有返回值的线程 6
有返回值的线程 7
有返回值的线程 8
有返回值的线程 9
有返回值的线程 10
有返回值的线程 11
有返回值的线程 12
有返回值的线程 13
有返回值的线程 14
main 的循环变量i的值30
·····
有返回值的线程 32
有返回值的线程 33
有返回值的线程 34
有返回值的线程 35
有返回值的线程 36
有返回值的线程 37
有返回值的线程 38
有返回值的线程 39
有返回值的线程 40
有返回值的线程 41
main 的循环变量i的值31
main 的循环变量i的值32
main 的循环变量i的值33
main 的循环变量i的值34
main 的循环变量i的值35
main 的循环变量i的值36
main 的循环变量i的值37
有返回值的线程 42
有返回值的线程 43
有返回值的线程 44
有返回值的线程 45
main 的循环变量i的值40
子线程的返回值：100

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

• 采用实现Runnable，callable 接口方式创建线程的时候，线程只是实现了Runnable和Callable接口，还可以继承其他类
• 使用继承Thread类的创建方式时，编写简单，如果说需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

• 线程同步
• 线程之间的通信
• 线程死锁