多线程编程

记得开心一点啊

于 2023-10-24 00:30:00 发布

阅读量96

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/qq_61872165/article/details/133976255

版权

♫什么是线程

我们已经知道进程能充分利用CPU，实行并发编程，但因为进程消耗资源多且执行速度慢，所以就有了比进程更轻量的线程（线程创建，销毁和调度所需开销都比进程低），因此线程也被称为“轻量级进程”。

线程可以看作是进程中的一个实体，一个进程可以包含一个或多个线程，这些线程共享进程的同一份资源（主要指内存（一个线程new的对象其他线程也能用）和文件描述符表（一个线程打开的文件其他线程也能用）），但是每个线程都拥有自己的栈空间和局部变量，都可以执行各自的上下文，且不会相互影响。

注：线程是系统调度的最小单位，进程是系统资源分配的最小单位

♫Java的线程和操作系统线程的关系

线程是操作系统中的概念，操作系统内核实现了线程这样的机制，并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库)。Java虚拟机JVM对很多操作系统提供的API进行封装，因此我们只需了解JVM提供的API就能进行Java 线程的相关操作。标准库中的 Thread 类就是对操作系统提供的 API 进行了进一步的抽象和封装的类。

♫第一个多线程代码

Thread类在Java.lang包（java的内置包，无需显式导入）下，创建线程主要用到Thread类的两个方法：

♩.start()：start()的作用是调用系统的API，通过操作系统内核创建新的线程，并把要执行的指令交给新线程，当新线程调度到CPU上执行是，就执行到run()方法。

♩.run()：run()是线程要执行的任务

下面就是通过继承Thread，重写run()的方式在主线程下创建了一个新线程thread，主线程和thread线程并发打印五次自己的线程名：
class MyThread extends Thread {
    @Override
    public void run() {
        int a = 5;
        while (a-- > 0) {
            //打印该线程的线程名
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class ThreadDemol {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        //创建线程
        thread.start();
        int a = 5;
        while (a-- > 0) {
            //打印所在线程的线程名
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
运行结果如下：

注：

①.由于线程之间是抢占式执行的，所以在应用程序这一层无法判断main线程和thread线程谁先执行，谁后执行。

②.public static Thread currentThread()方法用于返回当前线程对象的引用。（类比获取所在对象的this）

③.public static void sleep(long millis) throws InterruptedException方法用于休眠当前线程millis毫秒。

使用jdk自带的jconsole工具可以查看java进程里的所有线程：

点进thread.ThreadDemol就可以查看进程里的线程：

♫Thread类常见的构造方法

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

Thread(ThreadGroup group, Runnable target)

线程可以被用来分组管理，分好的组即为线程组
Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("张三");
Thread t4 = new Thread(new MyRunnable(), "李四");
注：t3和t4是代码里的线程名，张三和李四是系统里创建的线程名

♫创建线程的方式

♪继承Thread类

创建一个继承Thread类的子类，并重写run方法，通过调佣start创建线程：

//继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        //线程执行内容
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }
}

♪使用匿名内部类继承Thread类

还可以通过使用匿名内部类的方式继承Thread类：

//使用匿名内部类继承Thread类
public class ThreadTest {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        thread.start();
    }
}

♪实现Runnable接口

创建一个实现Runnable接口的类，并重写run方法，通过调用start创建线程：

//实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

♪使用匿名内部类实现Runnable接口

还可以通过匿名内部类实现Runnable接口：

//匿名内部类
public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

♪使用Lambda表达式

还可以把任务用Lambda表达式描述，直接将表达式传递给Thread的构造方法：

//使用lambda表达式创建Runnable子类对象
public class ThreadTest {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        });
    }
}

♫Thread类的常见属性

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

♩.ID 是线程的唯一标识，不同线程不会重复。

♩.名称 是各种调试工具用到。（指系统里的线程名）

♩.状态 表示线程当前所处的一个情况，下面我们会进一步说明。

♩.优先级 高的线程理论上来说更容易被调度到。（优先级可以获取也可以设置，只是设置了没啥用）

♩.守护线程 需要记住一点：JVM会在一个进程的所有非守护线程结束后，才会结束运行。（代码里主线程和自己创建的线程默认都是守护线程，其他JVM自带的线程则是守护线程）

♩.是否存活 即简单的理解为 run 方法是否运行结束了。（run()正在跑，isAlive()就是true；run()还没跑或run()跑完了，isAlive()就是false）

♩.线程是否中断 取决于线程本身的代码的实现。

♫线程终止

终止线程并不是让线程直接终止掉，而是通知线程应该终止，线程究竟终不终止取决于线程本身的代码实现（就好比老师布置的作业，你可以马上写，你也可以过会在写，你甚至还可以不写）。我们可以通过标志位来实现线程终止操作：

♪使用自定义的标志位

设置公共标志位flag，通过设置flag的值控制线程终止：
public class Test {
    public static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            while (flag) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        Thread.sleep(1000);
        //主线程里可以通过修改flag的值控制thread线程的终止
        flag = false;
    }
}
运行结果：

注：使用自定义标志位这种方式不能及时响应，尤其在sleep休眠时间较长的情况下

♪使用Thread自带的标志位

通过Thread.currentThread.isInterrupted()方法判断标志位，通过thread.interrupt()设置标志位来实现线程终止：
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}
运行结果：

可以观察到：使用interrupt()会令sleep捕获到InterruptedException异常，这样就能使sleep提前终止。此外，虽然interrupt修改了线程内部的标志位，但sleep在唤醒的时候会将标志位重新修改回去，因此在sleep被唤醒后仍会执行线程里的代码（不写作业）。当然我们也可以在sleep里加个break让线程立即终止（马上去写作业）：
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;-
                }
            }
        });
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}
运行结果：

当然，break也可以换成其它代码（过会再写作业），这取决于thread的代码实现。

♫等待一个线程

线程是随机调度的，等待一个线程就是让一个线程等待另一个线程执行后完毕再执行，这样可以控制两个线程执行的先后顺序。

等待一个线程可以通过join关键字来实现，下面就是一个main线程等待thread线程的例子：
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName());
        });
        thread.start();
        System.out.println("join前");
        thread.join();
        System.out.println("join后");
    }
}
运行结果：

上面这种写法相当于main线程死等thread线程，我们还可以通过传递参数，让main线程阻塞等待thread一定时间，thread线程执行完毕或超过指定的时间main线程都会开始执行：
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName());
        });
        thread.start();
        System.out.println("join前");
        thread.join(100);
        System.out.println("100毫秒后");
    }
}
运行结果：

♫线程的状态

线程状态是针对当前线程调度的情况来描述的，线程的状态是一个枚举类型 Thread.State。通过for-earch可以遍历线程状态：
public class Test {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}
运行结果：

♩NEW（新建状态）：当线程对象被创建时，它处于新建状态。

♩RUNNABLE（就绪状态）：当线程对象被创建后，其他线程调用了该对象的 start() 方法时，该线程进入就绪状态。

♩BLOCKED（阻塞状态）：线程在等待某个监视器锁时，进入阻塞状态。

♩WAITING（等待状态）：线程在等待其他线程通知调度器已经满足了某个条件时，进入等待状态。

♩TIMED_WAITING（等待状态）：线程等待某个特定时间段的状态。

♩TERMINATED（终止状态）：run方法执行完毕，但Thread对象还在。

下面是各种状态的大致流程：

♫多线程的意义

多线程可以利用计算机的多个处理器核心或多个CPU实现并发执行多个任务，提高计算机的执行效率和性能。

对于CPU密集型的任务，多线程的执行速率远高于单线程，如：自增20亿次的操作，在单线程中花费的时间：

public class Test {
    public static void main(String[] args) {
        long beginTime = System.currentTimeMillis();
        long a = 0;
        for (long i = 0; i < 20_0000_0000L; i++) {
            a++;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间：" + (endTime-beginTime) + "ms");
    }
}

运行结果：

在多线程中花费的时间：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            long a = 0;
            for (long i = 0; i < 10_0000_0000L; i++) {
                a++;
            }
        });
        Thread t2 = new Thread(()->{
            long a = 0;
            for (long i = 0; i < 10_0000_0000L; i++) {
                a++;
            }
        });
        //记录开始执行的时间
        long beginTime = System.currentTimeMillis();
        t1.start();
        t2.start();
        //主线程等待t1,t2线程都执行完
        t1.join();
        t2.join();
        //记录执行完毕的时间
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间：" + (endTime-beginTime) + "ms");
    }
}

运行结果：

注：多线程提供运行速率的前提是CPU是多核CPU，且核心处于空闲状态

记得开心一点啊

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
多线程编程

线程可以看作是进程中的一个实体，一个进程可以包含一个或多个线程，这些线程共享进程的同一份资源（主要指内存（一个线程new的对象其他线程也能用）和文件描述符表（一个线程打开的文件其他线程也能用）），但是每个线程都拥有自己的栈空间和局部变量，都可以执行各自的上下文，且不会相互影响。start()的作用是调用系统的API，通过操作系统内核创建新的线程，并把要执行的指令交给新线程，当新线程调度到CPU上执行是，就执行到run()方法。需要记住一点：JVM会在一个进程的所有非守护线程结束后，才会结束运行。
复制链接

扫一扫

方法	描述
Thread()	创建线程对象
Thread(Runnable target)	使用Runnable对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String namre)	使用Runnable对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)	线程可以被用来分组管理，分好的组即为线程组

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

多线程编程

♫什么是线程

♫Java的线程和操作系统线程的关系

♫第一个多线程代码

♫Thread类常见的构造方法

♫创建线程的方式

♪继承Thread类

♪使用匿名内部类继承Thread类

♪实现Runnable接口

♪使用匿名内部类实现Runnable接口

♪使用Lambda表达式

♫Thread类的常见属性

♫线程终止

♪使用自定义的标志位

♪使用Thread自带的标志位

♫等待一个线程

♫线程的状态

♫多线程的意义

“相关推荐”对你有帮助么？