【多线程】Thread 类及常见方法

1.Thread 类在Java标准库中，提供有一个Thread,来表示/操作线程。Thread 类也可以视为Java 标准库提供的API。创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类2.创建线程2.1继承Thread 类通过Thread 类创建线程，最基本的做法就是创

Fly upward

5657人浏览 · 2022-05-14 12:30:46

Fly upward · 2022-05-14 12:30:46 发布

1.Thread 类

在Java标准库中，提供有一个Thread,来表示/操作线程。

Thread 类也可以视为Java 标准库提供的API。

创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。

操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类

2.创建线程

2.1继承Thread 类

通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法

（1）继承Thread 来创建一个线程类

重写run方法里面的输出是描述了这个线程内部要执行的代码，每个线程都是并发执行的（各自执行各自的代码），因此就需要告知这个线程，你要执行的是什么

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello thread");
    }
}

（2）创建MyThread 类的实例

 Thread t = new MyThread();

（3）调用 start 方法启动线程

这一步才是真正的在系统中创建了线程，才能执行上诉的 run 方法

在调用 start 之前，系统中是没有创建出线程的

这里的创建线程，都是在同一个进程内部创建的

t.start(); // 线程开始运行

总的线程代码如下：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello thread");
    }
}
//最基本的创建线程的方法，都在同一个进程内
public class Test1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

2.2并发执行

在一个进程中，至少会有一个线程

在一个Java 进程中，也至少会有一个调用 main 方法的线程（IDEA 自动创建的main 线程）

自己创建的 t 线程和自动的 main 线程，就是并发执行的关系（宏观上看起来是并发执行的）

并发 = 并行 + 并发。（宏观上区分不了并行和并发都取决于系统内部的调度）

class MyThread2 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);//单位ms，即休眠一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 并发执行
 * 创建的Thread线程 和 本身的 main 线程一起执行
 */
public class Test2 {
    public static void main(String[] args) {
        Thread t2 = new MyThread2();
        t2.start();//Thread线程开始

        //main本身的线程
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在创建 t 线程中加入了 Thread.sleep(1000); //单位ms，即休眠一秒。就是为了让线程进入 1s 的阻塞状态，不然线程执行的很快，打印出来的看不过来。

每一轮 1s 时间过后，线程恢复，main 线程和 thread 线程都是随机唤醒的

2.3实现Runnable 接口

（1）实现Runnable 接口

（2）创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.

（3）调用 t.start(); // 线程开始运行


//Runnable 就是在描述一个 "任务"
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello runnable");
    }
}
//创建一个类实现Runnable 接口，再创建实例转化给Thread 类
public class Test3 {
    public static void main(String[] args) {
        Thread t3 = new Thread(new MyRunnable());
        t3.start();
    }
}

2.4匿名内部类

（1）匿名内部类创建 Thread 子类对象

创建一个匿名内部类，继承自 Thread 类，同时重写 run 方法，同时在new 出这个匿名内部类的实例

public class Test4 {
    public static void main(String[] args) {
        Thread t4 = new Thread() {
            @Override
            public void run() {
                System.out.println("内部类");
            }
        };
        t4.start();
    }
}

（2）匿名内部类创建 Runnable 子类对象

new 的Runnable 针对这个创建的匿名内部类，同时 new 出的 Runnable 实例传给 Thread 的构造方法

public class Test4 {
    public static void main(String[] args) {
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable");
            }
        });
        t5.start();
    }
}

针对上述两种匿名内部类，通常认为 Runnable 的写法更好一点，其能够做到让线程和进程执行任务的时候，更好的进行解耦

（3） lambda 表达式创建 Runnable 子类对象

lambda 代替了Runnable

//使用 lambda 表达式
public class Test5 {
    public static void main(String[] args) {
        Thread t5 = new Thread(() -> {
            System.out.println("lambda");
        });
        t5.start();
    }
}

3.多线程的优势

多线程可以增加运行速度，可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

记录时间，可以使用时间戳函数 currentTimeMillis()

（1）举个例子，先创建一个线程让 a 、b 变量进行自增 100亿次，然后看看所消耗的时间

public class Test6 {
    //一个线程运行两个变量
    private static final long count = 100_0000_0000L;

    public static void serial() {
        //记录程序执行时间
        long beg = System.currentTimeMillis();
        long a = 0;
        for (long i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (long i = 0; i < count; i++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("消耗时间 ： " + (end - beg) + "ms");
    }

   
    public static void main(String[] args) throws InterruptedException {
        serial();
      
    }
}

使用了11784 ms

（2）创建两个线程，一个线程对一个变量进行自增

join 效果就是等待线程结束. t1.join 就是让 main 线程等待 t1 结束. t2.join 让 main 线程等待 t2 结束.

public class Test6 {
 
    //两个线程
    public static void concurrency() throws InterruptedException {
        long beg = System.currentTimeMillis();
        //线程一
        Thread t1 = new Thread(() ->{
            long a = 0;
            for (long i = 0; i < count; i++) {
                a++;
            }
        });
        t1.start();

        //线程二
        Thread t2 = new Thread(() ->{
            long b = 0;
            for (long i = 0; i < count; i++) {
                b++;
            }
        });
        t2.start();

        // 此处不能直接这么记录结束时间. 别忘了, 现在这个求时间戳的代码是在 main 线程中.
        // main 和 t1 t2 之间是并发执行的关系, 此处 t1 和 t2 还没执行完呢, 这里就开始记录结束时间了. 这显然是不准确的.
        // 正确做法应该是让 main 线程等待 t1 和 t2 跑完了, 再来记录结束时间.
        // join 效果就是等待线程结束. t1.join 就是让 main 线程等待 t1 结束. t2.join 让 main 线程等待 t2 结束.
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("消耗时间 ： " + (end - beg) + "ms");
    }
    public static void main(String[] args) throws InterruptedException {
        
        concurrency();//多线程，要抛出异常 throws
    }
}

使用了 7438 ms

4.Thread 类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。

4.1 Thread 的常见构造方法

方法	说明
Thread()	创建线程对象
Thread(Runnable target)	使用 Runnable 对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名

使用如下

Threadt1 = new Thread ();

Threadt2 = new Thread ( new MyRunnable ());

Threadt3 = new Thread ( " 这是我的名字 " );

Threadt4 = new Thread ( new MyRunnable (), " 这是我的名字 " );

对 Thread(String name) 进行使用说明

public class Test7 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() ->{
            while (true) {
                System.out.println("hello thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread1");
        t1.start();


        Thread t2 = new Thread(() ->{
            while (true) {
                System.out.println("hello thread2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread2");
        t2.start();
    }

}

代码中的 thread t1 、 thread t2 就可以通过以下方式查看

4.2Thread 的几个常见属性

属性	获取方法
ID	getId()
名称	getName( )
状态	getState( )
优先级	getPriority( )
是否后台线程	isDaemon( )
是否存活	isAlive( )
是否被中断	isInterrupted( )

（1）是否后台线程

如果线程是后台线程，就不影响进程退出。是前台线程，就会影响进程退出

现在所创建的线程默认都是前台的线程，即使main 方法，进程也不能退出，得等到 t1、 t2都执行完，整个进程才能退出。

（2）是否存活

操作系统中对应的线程是否正在运行，

Thread t 对象的生命周期和内核中对应的线程，生命周期并不完全一致，创建出t 对象之后，在调用 start 之前，系统中是没有对应线程的。在 run 方法执行之后，系统中的线程就销毁了，但是 t 这个对象可能还存在。通过 isAlive 就能判断当前系统的相差的运行情况。

如果调用 start 之后，run执行完之前，isAlive 就是返回 true

如果调用 start 之前，run执行完之后，isAlive 就是返回 false

4.3启动一个线程-start()

start 是一个特殊的方法，内部会在系统中创建线程。

run 单纯是一个普通的方法，描述了任务的内容

（1）先看start 方法的效果


public class Test8 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //t.run();//run 没有创建新的线程,只是一个普通的方法
        //同在一个main线程中，按先后顺序执行
        t.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

看运行结果可知，已经创建的一个线程，和本身的main线程并发执行

（2）run 方法的效果

将上述代码的 t.start( ) 替换成 t.run( ).

run只是执行方法，按先后运行，向将 "hello thread" 执行完一个循环，在进行下一个循环。

4.4中断一个线程

中断线程就是让一个线程停下来，关键就是让run方法执行完

（1）手动的设置一个标志位（自己创建变量，boolean）,来控制线程是否要结束。

通过main 本身线程向进入阻塞5s，然后和创建的 t 线程并发执行，isQuit = true 就会阻挡 t 线程的循环，从而将线程中断


//在main线程中做个休眠唤醒来终止创建的线程
public class Test9 {
    private static boolean isQuit = false;//main 线程
    public static void main(String[] args) {

        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t.start();//创新线程，开始执行

        // 只要把这个 isQuit 设为 true, 此时这个循环就退出了, 进一步的 run 就执行完了, 再进一步就是线程执行结束了.

        try {
            Thread.sleep(5000);//main线程休眠5s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        isQuit = true;
        System.out.println("终止 t 线程");
    }
}

（2）Thread.interrupted() 或者 hread.currentThread().isInterrupted()

//线程中断
public class Test10 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //当触发异常之后, 立即就退出循环~
                    System.out.println("线程中止");
                    break;
                }
            }
        });
        t.start();

        //main线程休眠5s
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 在主线程中,休眠5s后 调用 interrupt 方法, 来中断这个线程.
        // t.interrupt 的意思就是让 t 线程被中断!!
        t.interrupt();
    }
}

调用 t. interrupt( ) 这个方法，可能产生两种情况：

如果 t 线程是处于就绪状态，就是设置线程的标志位为 true

如果 t 线程处于阻塞状态（sleep休眠了），就会触发一个InterruptedException，从而退出线程

4.5等待一个线程 join()

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。

通过调用 join 的时候，那个线程调用 join ，哪个线程就会阻塞等待，等到对应的线程执行完毕为止（对应的run 执行完毕）

如下最多阻塞10s，如果Thread线程还没结束就直接强制结束

t.join(10000)

public class Test11 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        // 在主线程中就可以使用一个等待操作. 来等待 t 线程执行结束.
        try {
            t.join(10000);//最多等待10s，如果Thread线程还没结束就直接强制结束。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4.6获取当前线程引用

Thread.currentThread().getName() 就能获取到当前线程的引用（Thread 实例的引用）。

那个线程调用 currentThread ，就获取到的是那个线程的实例

 Thread t = new Thread() {
            @Override
            public void run() {
                // System.out.println(Thread.currentThread().getName());
                System.out.println(this.getName());
            }
        };