侧边栏壁纸
博主头像
银河小徐博主等级

A Good Boy ⛵️⛵️⛵️

  • 累计撰写 42 篇文章
  • 累计创建 39 个标签
  • 累计收到 10 条评论

目 录CONTENT

文章目录

Java 多线程的实现

银河小徐
2022-03-07 / 0 评论 / 10 点赞 / 83 阅读 / 2,758 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-06-04,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

进程和线程之间的关系

线程是在进程基础之上创建并使用的更小的程序单元,所以线程依赖于进程的支持。线程的启动速度要比进程快上很多,高并发处理的时候,线程的性能要高于进程。

  • 进程:指在系统中正在运行的一个应用程序;程序一旦运行就是进程;进程——资源分配的最小单位。
  • 线程:系统分配处理器时间资源的基本单元,或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

多线程实现的四种方式

  1. 继承Thread类,重写run方法。
  2. 实现Runnable接口,重写run方法。
  3. 通过Callable和FutureTask创建线程
  4. 通过线程池创建线程

代码示例

继承Thread类

/**
 * @author: Xuxu
 * @date: 2020-08-10 10:00
 **/
public class ThreadTest1 extends Thread {
    @Override
    public void run() {
        // 线程代码区
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadTest1 threadTest1 = new ThreadTest1();
        threadTest1.setName("线程1");
        threadTest1.start();
        System.out.println(Thread.currentThread().toString());
    }
}

运行结果:

Thread[main,5,main]
线程1:我是通过继承Thread类实现的

实现Runnable接口

/**
 * @author: Xuxu
 * @date: 2020-08-10 10:19
 **/
public class ThreadTest2 {
    static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread());
        thread.setName("线程2:我是通过Runnable接口实现的");
        thread.start();
        System.out.println(Thread.currentThread().toString());
    }
}

运行结果:

Thread[main,5,main]
线程2:我是通过Runnable接口实现的

通过Callable和FutureTask创建线程

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

/**
 * @author: Xuxu
 * @date: 2020-08-10 10:28
 **/
public class ThreadTest3 {
    static class MyThread<Object> implements Callable<Object> {
        @Override
        public Object call() {
            System.out.println(Thread.currentThread().getName());
            return null;
        }
    }

    public static void main(String[] args) {
        Callable<Object> callable = new MyThread<>();
        FutureTask<Object> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.setName("线程3:我是通过Callable和FutureTask创建的");
        thread.start();
        System.out.println(Thread.currentThread().toString());
    }
}

运行结果:

Thread[main,5,main]
线程3:我是通过Callable和FutureTask创建的

通过线程池创建线程

import java.util.concurrent.ExecutorService;

import static java.util.concurrent.Executors.*;

/**
 * @author: Xuxu
 * @date: 2020-08-10 10:39
 **/
public class ThreadTest4 {

    //线程池数量
    private static int POOL_NUM = 10;

    static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = newFixedThreadPool(5);
        for (int i = 0; i < POOL_NUM; i++) {
            MyThread myThread = new MyThread();
            executorService.execute(myThread);
        }
        //关闭线程池
        executorService.shutdown();
    }
}

运行结果:

通过线程池方式创建的线程:pool-1-thread-2
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-2
通过线程池方式创建的线程:pool-1-thread-3
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-5
通过线程池方式创建的线程:pool-1-thread-2
通过线程池方式创建的线程:pool-1-thread-4

线程运行状态

对于多线程的开发而言,编写程序的过程中总是按照:定义线程的主体类,然后通过Thread类进行线程的启动,但是并不意味着你调用了start()方法,线程就已经开始启动了,因为整体的线程处理有自己的一套运行状态。

10

评论区