Java 多线程基础实践（含demo）

Java多线程运行机制

线程的生命周期及运行过程中的各个状态

• 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
• 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
• 运行状态(Running): 线程获取CPU权限进行执行。run方法运行。需要注意的是，线程只能从就绪状态进入到运行状态。
• 阻塞状态(Blocked):     表示线程阻塞于锁。
• 等待状态(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
• 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
• 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Java实现多线程的3种方式

继承Thread类

新建FirstThread类，继承Thread类，重写run方法。

public class FirstThread extends Thread{
    private String title;

    public FirstThread(String title){
        this.title = title;
    }

    @Override
    public void run(){
        for(int i = 0; i < 20; i++){
            System.out.println(this.title+"运行："+i);
        }
    }
}

实现Runnable接口

新建SecondThread类，实现Runnable接口，实现run方法。

public class SecondThread implements Runnable{
    private String title;

    public SecondThread(String title){
        this.title = title;
    }

    @Override
    public void run() {
        for(int i = 0; i < 20; i++){
            System.out.println(this.title+"运行："+i);
        }
    }

Callable实现多线程

从最传统的开发来讲如果要进行多线程的实现肯定依靠的就是Runnable，但是Runnable接口有一个缺点：当线程执行完毕后，我们无法获取一个返回值，所以从JDK1.5之后就提出了一个新的线程实现接口：java.util.concurrent.Callable接口。

import java.util.concurrent.Callable;

/**
 * 实现该接口可获得线程返回值
 */
public class ThirdThread implements Callable<String> {
    private String title;

    public ThirdThread(String title){
        this.title = title;
    }

    @Override
    public String call() throws Exception {
        for(int i = 0; i < 20; i++){
            System.out.println(this.title+"运行："+i);
        }
        return this.title + "线程执行完成";
    }
}

线程测试

import java.util.concurrent.FutureTask;

public class TestThread {

    /**
     * 实现多线程的三种方式
     * @throws Exception
     */
    @Test
    public void test1() throws Exception{
        // 1.继承Thread
        FirstThread a = new FirstThread("A");
        // 打印线程状态
        System.out.println(a.getState());
        a.start();
        System.out.println(a.getState());
        // 2.实现Runnable接口
        SecondThread bTemp = new SecondThread("B");
        Thread b = new Thread(bTemp);
        b.start();
        // 3.实现Callable接口，这种方式可以获取线程返回值
        ThirdThread cTemp = new ThirdThread("C");
        FutureTask futureTask = new FutureTask(cTemp);
        Thread c = new Thread(futureTask);
        c.start();
        System.out.println(futureTask.get()+"");
    }

}

运行结果：start方法让线程进入就绪状态，实际运行还需看CPU的调度

线程阻塞

对于线程的阻塞，考虑一下三个方面，不考虑IO阻塞的情况：睡眠； 等待； 因为需要一个对象的锁定而被阻塞。

线程睡眠

• 可通过Thread.sleep()的静态方法使线程进入阻塞状态，设置阻塞时间结束之后可重新进入就绪（可运行）状态。
• sleep设置的是阻塞的最短时间。阻塞时间结束之后不能保证线程马上运行。线程睡眠是帮助所有线程获得运行机会的最好方法。
• sleep()是静态方法，只能控制当前正在运行的线程。

public class SecondThread implements Runnable{
    private String title;

    public SecondThread(String title){
        this.title = title;
    }

    @Override
    public void run() {
        try {
            for(int i = 0; i < 20; i++){
                if(i==1){
                    // 睡眠指定时间，并不能保证线程会精确地休眠到你指定的时间点
                    // 睡眠结束进入的是可执行状态，具体还需看CPU调度
                    Thread.sleep(1);
                }
                System.out.println(this.title+"运行："+i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程的优先级

 线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority()更改线程的优先级。

线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。

Thread thread = new Thread();  
thread.setPriority(6);  
thread.start();  

 线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：

static intMAX_PRIORITY：线程可以具有的最高优先级。  
static intMIN_PRIORITY：线程可以具有的最低优先级。  
static intNORM_PRIORITY：分配给线程的默认优先级。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

线程让步yield()

• Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
• 线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
• yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

public class FirstThread extends Thread{
    private String title;

    public FirstThread(String title){
        this.title = title;
    }

    @Override
    public void run(){
        for(int i = 0; i < 10; i++){
            if(i==5){
                Thread.yield();
            }
            System.out.println(this.title+"运行："+i);
        }
    }
}

添加测试方法

 @Test
    public void test2(){
        // 线程让步
        FirstThread a = new FirstThread("A");
        ThirdThread cTemp = new ThirdThread("C");
        FutureTask futureTask = new FutureTask(cTemp);
        Thread c = new Thread(futureTask);
        // 设置相同的线程优先级（不可靠）
        a.setPriority(6);
        c.setPriority(6);
        a.start();
        c.start();
    }

运行结果

join()方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。

另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

新建JoinThread类

public class JoinThread implements Runnable{
    private Thread thread;

    public JoinThread(Thread thread){
        this.thread = thread;
    }

    @Override
    public void run() {
        try {
            this.thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "尾部加入成功");
    }
}

测试

    /**
     * 线程join
     */
    @Test
    public void test3(){
        // Thread.currentThread表示当前代码段正在被哪个线程调用的相关信息
        Thread previous = new FirstThread("first");
        Thread thread = new Thread(new JoinThread(previous),"second");
        thread.start();
        previous.start();

    }

运行结果

总结

以上就是Java实现多线程的三种方式及线程中关于线程阻塞基础方法的使用。这篇文章主要介绍了Java多线程的基础用法，关于多线程的知识远不止这些，为避免本文篇幅过长，关于多线程的其他知识点笔者会在接下来的文章中为大家介绍~~