Java多线程教程（从0到1）

最新推荐文章于 2023-08-05 11:47:40 发布

坠入云幕间KN

最新推荐文章于 2023-08-05 11:47:40 发布

阅读量160

点赞数

本文链接：https://blog.csdn.net/qq_42341467/article/details/127329864

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

多线程

更多笔记 https://gitee.com/TomAndJery/notes.git

多线程是什么？为什么要用多线程？

进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；

线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。

多线程：一个进程中不只有一个线程。

为什么要用多线程?

为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；
进程之间不能共享数据，线程可以；
系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；
Java语言内置了多线程功能支持，简化了java多线程编程。

线程的声明周期

创建==>就绪==>运行==>等待/阻塞/睡眠==>死亡

新建：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；
就绪：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；
运行：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。
等待/阻塞/睡眠：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。
终止：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

创建线程的四种方式

直接继承Thread类，重写 run方法

public class TestThread extends Thread{
    @Override
    public void run() {
        System.out.println("Thrad....");
    }

    public static void main(String[] args) {
        //启动线程
        new TestThread().start();
    }
}

实现Runnable接口，实现run方法

public class TestThread implements Runnable{
    @Override
    public void run() {
        System.out.println("implements Runnable...");
    }

    public static void main(String[] args) {
        //启动线程
        new Thread(new TestThread()).start();
    }
}

实现Callable接口定义泛型，实现call方法，创建FutureTask将实现Callable接口的类放入构造函数中，最后使用创建Thread将FutureTask作为构造参数

public class TestThread implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("implements Callable...");
        return 1;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方法1
        //将实现Callable的类使用FutureTask进行包装
        FutureTask<Integer> futureTask = new FutureTask<>(new TestThread());
        new Thread(futureTask).start();
        Integer res = futureTask.get();
        System.out.println("返回结果："+res);
        
        
        //=================>方法2
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(1);
        /**
         * Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。
         * 必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
         */
        Future<Integer> submit = service.submit(new TestThread());
        //获取返回结果
        Integer res = submit.get();
        System.out.println("执行返回结果:"+res);
        //关闭线程池
        service.shutdown();
        
    }
}

使用线程池创建线程

线程状态管理

线程睡眠 Thread.sleep

通过调用Thread.sleep()即可让一个线程进入睡眠状态

倒计时实例

public class TestSleep {

    public static void main(String[] args) {
        //模拟倒计时
        countDown();
    }

    //倒计时
    public static void countDown(){
        int i = 10;
        while (true){
            System.out.println(i--);
            if(i<=0){
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程礼让 Thread.yield

礼让线程，让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让 CPU重新调度，礼让不一定成功！

public class TestYield {
    public static void main(String[] args) {
        ThreadYield threadYield = new ThreadYield();

        new Thread(threadYield,"a").start();
        new Thread(threadYield,"b").start();
        //运行结果：
        //a线程开始执行！
        //b线程开始执行！
        //b线程停止执行！
        //a线程停止执行！
    }
}

class ThreadYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行！");
        //礼让线程，第一次a进来，打印一句后进入就绪状态，礼让b执行完毕，然后继续执行a礼让之后的代码
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行！");
    }
}

等待改线程终止 Join

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

可以想象成插队,也就是等待该线程终止

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("我是vip...."+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread thread = new Thread(new TestJoin());
        thread.start();

        for (int i = 0; i < 500; i++) {
            if(i==200){
                //让指定线程插队
                thread.join();
            }
            System.out.println("MainRun........"+i);
        }
    }
}

线程状态 Thread.state

标识	解释
NEW	尚未启动的线程
RUNNABLE	在java虚拟机中执行
BLOCKED	被阻塞等待监视器锁定
WAITING	正在等待另一个线程执行特定动作
TIMED_WAITING	正在等待另一个线程执行动作达到指定等待时间
TERMINATED	已退出的线程处于此状态

使用Thread.sleep进行观测线程状态

public class ThreadState {
    public static void main(String[] args) {

        //创建线程
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行..." + i);
            }
        });

        //获取线程状态 当前线程还未启动
        Thread.State state = thread.getState();
        System.out.println("当前状态:"+state);

        //启动线程
        thread.start();
        for (int i = 0; i < 500; i++) {
            state = thread.getState();
            System.out.println("检测状态："+state);

            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(state==Thread.State.TERMINATED){
                System.out.println("线程结束！");
                break;
            }
        }
    }
}

线程优先级 Priority

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

线程优先级决定应该调度哪个线程来执行，设置优先级，优先级高的不一定优先执行，优先级的设定建议在start()之前

Thread对优先级定义的静态常量

 /**
     * 线程可以拥有的最小优先级。
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * 分配给线程的默认优先级。
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * 线程可以拥有的最大优先级。
     */
    public final static int MAX_PRIORITY = 10;

实例：

public class TestPriority {
    public static void main(String[] args) {

        Thread myThread1 = new Thread(new myThread(),"线程A");//5
        Thread myThread2 = new Thread(new myThread(),"线程B");//10
        Thread myThread3 = new Thread(new myThread(),"线程C");//1
        // Thread.MAX_PRIORITY = 10
        myThread2.setPriority(Thread.MAX_PRIORITY);
        // Thread.MIN_PRIORITY = 1
        myThread3.setPriority(Thread.MIN_PRIORITY);

        myThread1.start();
        myThread2.start();
        myThread3.start();

        /**
         * 执行结果：
         * 线程B正在执行...线程优先级：10
         * 线程A正在执行...线程优先级：5
         * 线程C正在执行...线程优先级：1
         */
    }

}

class myThread implements Runnable{
    @Override
    public void run() {
        int priority = Thread.currentThread().getPriority();
        System.out.println(Thread.currentThread().getName()+"正在执行...线程优先级："+priority);
    }
}

守护线程 Daemon

线程分为用户线程和守护线程

虚拟机必须保证用户线程执行完毕

虚拟机不需要等待守护进程执行完毕

public class ThreadDaemon {
    public static void main(String[] args) {
        Thread userThread = new Thread(new UserThread());
        userThread.start();//启动用户线程
        Thread daemonThread = new Thread(new DaemonThread());
        //设置为守护线程
        daemonThread.setDaemon(true);
        //启动守护线程
        daemonThread.start();
    }
}

/**
 *  用户线程
 */
class UserThread implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("用户线程执行中...");
        }
    }
}

/**
 * 通过Thread的setDaemon方法
 * 将用户线程修改为守护线程 Daemon = true
 */
class DaemonThread implements Runnable{
    @Override
    public void run() {
        //设置为守护线程后，当用户线程执行完毕后，自动停止
        //因为虚拟机不需要等待守护线程执行完毕
        while (true){
            System.out.println("守护线程执行中.....");
        }
    }
}

线程同步机制

并发： 同一个对象被多个线程 同时操作

例如：上万人同时抢100张票

由于同一进程的多线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入

锁机制 synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待使用后释放锁即可，但是还存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起；
在多线程竞争下，加锁，释放锁，会导致比较多的上下文切换和调度延时，引起性能问题。
如果一个优先级高的线程等待一个低优先级的线程释放锁，会导致优先级倒置，引起性能问题。

同步块：

同步块：synchronizd(Obj){}

Obj称为同步监视器

Obj可以是任意对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是对象本身，或者是class

同步监视器的执行过程：

第一个线程访问，锁定同步监视器，执行其中代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程执行完毕，解锁同步监视器
第二个线程发现同步监视器解锁，然后锁定访问、

抢票案例

/**
 * 抢票案例
 */
public class Test1 {
    public static void main(String[] args) {
        //创建线程对象
        BuyTicket buyTicket = new BuyTicket();
        //开启线程
        new Thread(buyTicket, "小林").start();
        new Thread(buyTicket, "黄牛党").start();
        new Thread(buyTicket, "小白脸").start();
    }
}

/**
 * 定义一个线程
 */
class BuyTicket implements Runnable{
    //定义票数
    private int ticketNumber = 10;
    //定义标志
    private boolean flag = true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //定义买票方法 synchronized 同步方法
    public synchronized void buy() throws InterruptedException {
        if(ticketNumber<=0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        //买条
        System.out.println(Thread.currentThread().getName()+"抢到了第"+ticketNumber--+"张票");
    }
}

同步方法和同步块的书写格式：

	//同步方法：同步方法的同步监视器就是this本身 
    public synchronized void buy()
    //同步块:同步块的同步监视器是Obj，Obj可以是任意对象
    synchronized(Obj){}

CopyOnWriteArrayList

JUC并发包中的安全的集合

增删改都需要获得锁，读取不需要性能比Vector高

每个增删改都上了锁，CopyOnWriteArrayList适用于读多写少的情况

死锁

线程死锁是指两个活两个以上线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该锁释放之前，其他线程是获取不到这个锁的，而且会一直等下去，因此就造成了死锁

死锁产生条件

互斥条件：一个资源，或者说一个锁只能被一个线程占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其他线程无法获得这个锁。
占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
不可剥夺条件：任何一个线程都无法强制获得别的线程已经占有的锁
循环等待条件：线程A拿着线程B，线程B拿着线程A的锁

死锁例子

/**
 * 死锁例子
 */
public class ThreadLock {
    public static void main(String[] args) {
        //开启两条线程
        new DeadThread(0,"白血公主").start();
        new DeadThread(1,"灰姑狼").start();
        //运行输入内容... 处于卡死状态 （死锁）
        //白血公主获取到口红对象锁！
        //灰姑狼获取到镜子对象锁！
    }
}
/**
 * 线程
 */
class DeadThread extends Thread{

    //镜子
    static Mirror mirror =  new Mirror();
    //口红
    static Lipstick lipstick = new Lipstick();
    //当前名称
    String name;
    //选择状态
    int state;

    public DeadThread(int state,String name){
        this.state = state;
        this.name = name;
    }

    @Override
    public void run() {
        try {
            operation();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //具体操作
    public void operation() throws InterruptedException {
        if(state==0){
            //获取口红对象锁
            synchronized (lipstick){
                System.out.println(name+"获取到口红对象锁！");
                //延时保证另一个线程也拿到对方的共享资源
                Thread.sleep(1000);
                //获取到镜子对象锁
                synchronized (mirror){
                    System.out.println(name+"获取到镜子对象锁！");
                }
            }


        }else{
            //获取到镜子对象锁
            synchronized (mirror){
                System.out.println(name+"获取到镜子对象锁！");
                //延时保证另一个线程也拿到对方的共享资源
                Thread.sleep(2000);
                //获取口红对象锁
                synchronized (lipstick){
                    System.out.println(name+"获取到口红对象锁！");
                }
            }
        }
    }



}

/**
 * 口红类
 */
class Lipstick {

}
/**
 * 镜子
 */
class Mirror{

}

// 解决方法 将synchronized 中的synchronized 放到同级，让其锁释放，再获取其他锁
//具体操作
    public void operation() throws InterruptedException {
        if(state==0){
            //获取口红对象锁
            synchronized (lipstick){
                System.out.println(name+"获取到口红对象锁！");
                //延时保证另一个线程也拿到对方的共享资源
                Thread.sleep(1000);
            }
            //获取到镜子对象锁
            synchronized (mirror){
                System.out.println(name+"获取到镜子对象锁！");
            }


        }else{
            //获取到镜子对象锁
            synchronized (mirror){
                System.out.println(name+"获取到镜子对象锁！");
                //延时保证另一个线程也拿到对方的共享资源
                Thread.sleep(2000);
            }
            //获取口红对象锁
            synchronized (lipstick){
                System.out.println(name+"获取到口红对象锁！");
            }
        }
    }

如何避免死锁

加锁顺序：线程按照相同的顺序加锁
加锁时限，线程获取锁的过程中限制一定的时间，如果给定时间内获取不到，就算了，别勉强自己。这需要用到Lock的一些API。

Lock（锁）

从JDK5.0开始，Java提供了更强大的线程同步机制，通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

Java.util.concurrent.locks.Lock接口是控制多线程对共享资源进行访问的工具。

锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

ReentrantLock（可重入锁）类实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

使用Lock实现类ReentrantLock实例

/**
 *  使用ReentrantLock实现类
 */
public class showLock {
    public static void main(String[] args) {

        ThreadLockDemo threadLockDemo = new ThreadLockDemo();

        new Thread(threadLockDemo,"A").start();
        new Thread(threadLockDemo,"B").start();
        new Thread(threadLockDemo,"C").start();
    }
}

/**
 * 线程对象
 */
class ThreadLockDemo implements Runnable{
    //创建10个数字
    private static int number = 10;
    //创建Lock接口实例
    private final ReentrantLock lock =  new ReentrantLock();

    @Override
    public void run(){
        while (true){
            try {
                //获取锁
                lock.lock();
                if(number>0){
                    //每次-1
                    System.out.println(number--+"---->"+Thread.currentThread().getName());
                    Thread.sleep(1000);
                }else{
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放锁
                lock.unlock();
            }
        }
    }
}

synchronize与Lock的对比

Lock是显式锁(手动开启和关闭锁，别忘记关闭锁）synchronize是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronize有代码块和方法锁
使用Lock锁，JVM将花费较少时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序
- Lock (使用ReentrantLock可重入锁) > 同步代码块（使用synchronize代码块包裹）> 同步方法 (在方法上加入synchronize)

效率问题（参考）：

在多线程环境并存在大量竞争的情况下，synchronized的用时迅速上升，而lock却依然保存不变或增加很少。（Lock性能好一点）

Lock是采用CAS来实现的，从JKD1.6之后synchronize也改用CAS来实现

线程协作

线程通信

应用场景：生产者和消费者问题

假设仓库中只能放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
- 如果仓库中放有产品，啧消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

线程通信分析:

对于生产者：没有生产产品之前，需要通知消费者等待，而生产产品之后又要马上通知消费者消费、
对于消费者：在消费之后，要通知生产者消费结束，需要生产新的产品以供消费

在生产者消费者问题中，仅有synchronize是不够的，synchronize可以阻止并发更新同一个共享资源，实现了同步，但是不能用于线程通信

Java提供了几个方法解决线程之间的通信问题 【均是Object类的方法，只能在同步方法中或者同步代码块中使用，否则抛异常】

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程优先调度

三个实例

管制法

生产者：生产后放入缓冲区，通知消费者消费

消费者：从缓冲区中消费，缓冲区消费完毕之后通知生产者生产

缓冲区（仓库）：存储数据

/**
 * 生产者消费者模型 ---> 利用缓冲区解决：管程法
 */
public class TestPc {
    public static void main(String[] args) {
        //创建仓库
        syncContainer syncContainer = new syncContainer();
        //创建消费者
        new Consumer(syncContainer).start();
        //创建生产者
        new Producer(syncContainer).start();

    }

}

/**
 * 生产者
 */
class Producer extends Thread{
    syncContainer syncContainer;

    public Producer(syncContainer syncContainer){
        super("生产者");
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            syncContainer.push(new Ikun(i+1));
            System.out.println("生产了ID:"+(i+1)+"的产品！");
        }
    }
}

/**
 * 消费者
 */
class Consumer extends Thread{
    syncContainer syncContainer;

    public Consumer(syncContainer syncContainer){
        super("消费者");
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("消费者===>>>"+(syncContainer.pop().id)+"个Ikun！");
        }
    }
}

/**
 * 产品 鸡
 */
class Ikun{
    //产品ID
    int id;

    public Ikun(int id){
        this.id = id;
    }


}

/**
 * 缓存容器
 */
class syncContainer{

    //创建容器长度10
    Ikun[] ikuns = new Ikun[10];
    //定义计数器
    int count = 0;

    //生产 添加
    public synchronized void push(Ikun ikun)  {
        //判断是否存满
        if(count==ikuns.length-1){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        ikuns[count] = ikun;
        count++;
        System.out.println("----->"+count);
        this.notifyAll();
    }

    //消费 减少
    public synchronized Ikun pop(){
        //判断有没有消费完,如果消费完count==0
        if(count==0){
            try {
                //等待生产者生产
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        //正常消费
        Ikun ikun = ikuns[count];

        this.notifyAll();
        return ikun;
    }

}

信号灯法

使用flag标识进行控制线程的通信

生产者：检测flag值，生产产品，生产完毕后通过修改flag标识通知消费

消费者：检测到flag值，进行消费，消费完毕后修改flag标识通知生产

/**
 * 生产者消费者：信号灯法
 * 使用标志位进行控制
 */
public class Test2 {

    public static void main(String[] args) {
        Tv tv = new Tv();
        //创建表演者线程
        new Player(tv).start();
        //创建观看者线程
        new Watcher(tv).start();
    }
}

/**
 * 生产者--->演员
 */
class Player extends Thread{
    Tv tv;
    public Player(Tv tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                tv.play("大话西游");
            }else{
                tv.play("喜之郎果肉果冻广告");
            }
        }
    }
}

/**
 * 消费者-->观众
 */
class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.show();
        }
    }
}
/**
 * 产品--->节目
 */
class Tv{
    //表演名称
    private String showName;
    //标识符，控制线程通信
    private Boolean flag = true;

    //表演
    public synchronized void play(String showName){
        //如果false就等待
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.showName = showName;
        System.out.println("正在表演："+showName);
        //修改标识符
        this.flag = !this.flag;
        //表演完成让另个线程观看
        this.notifyAll();
    }

    //观看
    public synchronized void show(){
        //如果flag=true就等待表演
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("正在观看："+showName);
        //修改标识符
        this.flag = !this.flag;
        //观看完毕，让其表演
        this.notifyAll();
    }

}

线程池

解决问题：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中

可以避免频繁创建销毁、实现重复利用，类似生活中的共享物品

使用线程池的优点：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中的线程，不需要每次创建）
便于线程管理
- corePollSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK5.0起提供了线程池相关API：ExecutorService 和 Executor

ExecutorService：真正的线程池接口，常见子类：ThreadPoolExecutor

void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runable
Future submit(Callable task):执行任务，有返回值，一般用来执行Callable
void shutdown():关闭连接池

Executor：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

public class TestExecutor{
    public static void main(String[] args) {
        //使用Executr静态方法创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.submit(new ThreadUser());
        service.submit(new ThreadUser());
        service.submit(new ThreadUser());
        //关闭线程池
        service.shutdown();
    }
}
//线程
class ThreadUser implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

参考：B站狂神视频 —— Java多线程

坠入云幕间KN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程教程（从0到1）

**为什么要用多线程?**1. 为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；2. 进程之间不能共享数据，线程可以；3. 系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；4. Java语言内置了多线程功能支持，简化了java多线程编程。
复制链接

扫一扫