并发编程——多线程基础

最新推荐文章于 2024-07-13 13:55:40 发布

又一年夏

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量38

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_47604668/article/details/132189531

版权

前言

在日常生活中，我们在计算机上可以打开微信、浏览器、QQ音等等，此时似乎给用户造成了一种错觉，计算机在同时执行着多个任务，其实不然，计算机在某一时刻，只能执行一个任务，那么为什么会造成同时运行多个任务的错觉呢？首先第一点、cpu运算速度非常快，一秒钟可一个执行多个任务，我们是感知不到的，并且在操作系统中，任务的执行并不是按照先来后到执行的，而是谁具备了执行条件谁就执行，那么在同一时刻，多个任务在cpu上交替执行，所以造成了同一时刻多个任务执行的假象。每一个任务就可以看作一个线程，同一时刻执行多个任务，就是多线程。

线程的实现`

1.继承Thread类

1.1 创建线程

/**
 * 第一种创建线程的方法：继承Thread类
 */
//1.继承Thread类
public class ThreadDemo06 extends Thread{

    //2.重写其中的run()方法
    @Override
    public void run() {//run()方法中是线程执行的任务代码
        //循环打印100次
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "： " + i);
        }
    }
}


class test{
    public static void main(String[] args) {
        //3.创建线程对象
        ThreadDemo06 t1 = new ThreadDemo06();

        ThreadDemo06 t2 = new ThreadDemo06();

        //4.启动线程，使用Thread类的start()方法，让操作系统真正意义上创建一个新的线程

        t1.start();
        t2.start();
    }
}

这两个线程，各自循环打印了100，那么会出现怎样的结果呢？
在这里插入图片描述
可以看到控制台在交替打印结果，一会打印线程一的结果一会打印线程二得结果，如何观察到线程呢？

1.2 观察操作系统中的线程

首先我们找到系统安装的JDK目录，在目录下的bin目录中有个jconsole.exe，双击打开

在这里插入图片描述
勾选本地连接，选择正在运行的类，点击线程，我们在左下角就可以看到，两个正在运行的线程，线程的默认名称是从0开始的。

选择Thread 0线程，可以查看线程信息，线程的状态。

2.实现Runnable接口


/**
 * 线程创建的第二种方法：实现Runnable接口
 */
class MyRunnable implements Runnable{

    //2.重写其中的run()方法
    @Override
    public void run() {//run()方法中是线程执行的任务代码
        //循环打印100次
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "： " + i);
        }
    }
}
public class ThreadDemo07 {

    public static void main(String[] args) {
        //3.创建实现类的对象
        MyRunnable myRunnable = new MyRunnable();
        //4.将myRunnable作为参数传递给Thread对象
        Thread t1 = new Thread(myRunnable,"线程一");

        Thread t2 = new Thread(myRunnable,"线程二");
        
        //5.真正意义上创建线程，调用start方法
        
        t1.start();
        t2.start();
    }
}

方式一和方式二的比较：

开发中优先选择实现Runnable接口的方式
原因：
（1）实现的方式没有类的单继承性的局限性
（2）实现的方式更适合来处理多个线程有共享数据的情况
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
还有就是，使用Runnable接口，使得线程创建步骤清晰，明了，代码逻辑完善，可读性变强。

3.匿名内部类

public static void main(String[] args) {
        
        //1.直接new Runnable接口 并且自动实现run方法
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "： " + i);
                } 
            }
        },"线程一");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "： " + i);
                }  
            }
        });

       //2.真正意义上创建线程，调用start方法

        t1.start();
        t2.start();
    }

4.lambda表达式实现

public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);

            }
        },"线程一");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);

            }
        },"线程二");

        t1.start();
        t2.start();
    }

5.实现callable接口

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable come in");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1024;
    }
}

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //使用构造方法：FutureTask(Callable<V> callable)
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread());

        new Thread(futureTask, "AAA").start();
        //new Thread(futureTask, "BBB").start();//复用，直接取值，不要重启两个线程
        //PS：多个线程来抢一个futureTask，里面的计算方法call()只计算一次，要想多次算，要创建多个FutureTask<V>对象

        int a = 100;
        int b = 0;

        //b = futureTask.get();//要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，直到计算完成
        while (!futureTask.isDone()) {//当futureTask完成后取值
            b = futureTask.get();
        }
        System.out.println("Result=" + (a + b));
    }
}

实现Callable接口的方式创建线程的强大之处

1.call()可以有返回值的，对于Thread的run（）方法和Runnable的run（）方法返回值类型都是void
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的

到这里有很多小伙伴就会好奇，有这么多种实现方式，但是也没有直观感受到多线程的效率比正常代码实现的快，那么接下来我们进行普通代码块执行效率和多线程执行效率的比较。

观察多线程执行效率

首先看一下以下代码

public class Test01 {

    public static void main(String[] args) {
        long beg  = System.currentTimeMillis();
        long a = 0;
        for (long i = 0; i < 1_000_0000_0000L; i++) {
            a++;
        }
        long b = 0;
        for (long i = 0; i < 1_000_0000_0000L; i++) {
            b++;
        }
        long end  = System.currentTimeMillis();

        System.out.println(end - beg);
    }
}

这里呢分别将a和b累加100000000000次，记录运行前的时间，和运行后的时间，最后打印开始时间和结束时间的差值，我们来看看运行时间，
在这里插入图片描述
运行时间达到了4万多毫米，我们再来看看多线程完成这个任务

public static void main(String[] args) {
        long beg = System.currentTimeMillis();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                long a = 0;
                for (long i = 0; i < 1_000_0000_0000L; i++) {
                    a++;
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                long a = 0;
                for (long i = 0; i < 1_000_0000_0000L; i++) {
                    a++;
                }
            }
        });

        t1.start();
        t2.start();

        long end = System.currentTimeMillis();

        System.out.println(end - beg);
    }

t1和t2两个线程分别对a累加100000000000次，我们来看看运行结果
在这里插入图片描述
只有11毫秒，天差地别，这个代码的比较，很直观的表现出多线程的优势，效率上大大提高。

总结

以上呢就是线程实现的五种方法，总结起来其实只有三种，第一种继承Thread类，第二种实现Runnable接口，对于匿名内部类和lambda表达式都是实现Runnable的一种变形，第三种就是实现callable接口，虽然步骤增多，但是优势也很明显，能够接收返回值。
采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

又一年夏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
并发编程——多线程基础

在日常生活中，我们在计算机上可以打开微信、浏览器、QQ音等等，此时似乎给用户造成了一种错觉，计算机在同时执行着多个任务，其实不然，计算机在某一时刻，只能执行一个任务，那么为什么会造成同时运行多个任务的错觉呢？首先第一点、cpu运算速度非常快，一秒钟可一个执行多个任务，我们是感知不到的，并且在操作系统中，任务的执行并不是按照先来后到执行的，而是谁具备了执行条件谁就执行，那么在同一时刻，多个任务在cpu上交替执行，所以造成了同一时刻多个任务执行的假象。
复制链接

扫一扫