投稿
  1. 极客之音首页
  2. 技术随笔

【JavaSE】一文搞懂Java多线程，代码示例，清晰明了（上）

飞熊 • • 技术随笔 • 阅读 188

梦想不抛弃苦心追求的人，只要不停止追求，你们会沐浴在梦想的光辉之中。再美好的梦想与目标，再完美的计划和方案，如果不能尽快在行动中落实，最终只能是纸上谈兵，空想一番。只要瞄准了大方向，坚持不懈地做下去，才能够扫除挡在梦想前面的障碍，实现美好的人生蓝图。【JavaSE】一文搞懂Java多线程，代码示例，清晰明了（上），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

Java多线程

前言

本文为Java多线程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、Java多线程简要概述

1.线程的核心概念

  1. 线程就是独立执行的路径
  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，比如 主线程，gc线程
  3. main()称之为主线程，为系统的入口，用于执行整个程序
  4. 在一个进程中，如果避开了多个线程，现成的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  5. 对同一份资源进行操作时，会存在资源抢夺的问题，需要加入并发控制
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、线程的创建

1.继承Thread

  1. 继承Thread类，重写run方法，调用Start()方法开启线程
  2. 不建议使用：为了避免OOP单继承的局限性

代码展示：

package com.wang.多线程;
// 创建线程方法一：继承Thread类，重写run方法，调用Start()方法开启线程
public class ThreadTest1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1200; i++) {
            System.out.println("Thread多线程" + i);
        }
    }
    public static void main(String[] args) {
        ThreadTest1 threadTest = new ThreadTest1(); // 创建一个线程对象
        threadTest.start(); // 调用start()方法开启线程
        for (int i = 0; i < 1200; i++) {
            System.out.println("main主线程" + i);
        }
    }
}


// 打印结果
main主线程0
Thread多线程0
Thread多线程1
Thread多线程2
Thread多线程3
Thread多线程4
main主线程1
Thread多线程5
.....
可以看得出来，这两个线程是同时在进行的

2.实现Runnable接口

  1. 重写run方法，执行线程需要丢入runnable接口实现类。调用start()方法
  2. 推荐使用：很好的避免了单继承的局限性，灵活方便，同一个对象被多个线程使用

代码展示

package com.wang.多线程;
public class RunnableTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1200; i++) {
            System.out.println("Runnable线程:" + i);
        }
    }
    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
        new Thread(runnableTest).start();
        for (int i = 0; i < 1200; i++) {
            System.out.println("main方法：" + i);
        }
    }
}


// 打印结果
main方法：0
Runnable线程:0
Runnable线程:1
Runnable线程:2
main方法：1
main方法：2
main方法：3
main方法：4
Runnable线程:3
....

3.实现Callable接口

  1. 创建一个实现Callable接口的类，实现call方法。将操作声明在call里。
  2. 创建Callable接口实现类的对象。然后创建执行服务，在提交服务，最后记得要关闭服务

代码展示：

package com.wang.多线程;
import java.util.concurrent.*;
public class CallableTest1 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "Callable:" + i);
        }
        return true;
    }
    public static void main(String[] args) throws Exception{
        CallableTest1 callableTest1 = new CallableTest1();
        CallableTest1 callableTest2 = new CallableTest1();
        CallableTest1 callableTest3 = new CallableTest1();
        // 创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 提交执行
        Future<Boolean> future1 = executorService.submit(callableTest1);
        Future<Boolean> future2 = executorService.submit(callableTest2);
        Future<Boolean> future3 = executorService.submit(callableTest3);
        // 获取结果
        boolean b1 = future1.get();
        boolean b2 = future2.get();
        boolean b3 = future3.get();
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        // 关闭服务
        executorService.shutdownNow();
    }
}
// 打印
pool-1-thread-3Callable:2
pool-1-thread-3Callable:3
pool-1-thread-3Callable:4
pool-1-thread-3Callable:5
pool-1-thread-3Callable:6
pool-1-thread-3Callable:7
pool-1-thread-1Callable:0
pool-1-thread-2Callable:0
pool-1-thread-2Callable:1
看这个3Callable和1Callable还有2Callable同时在输出

三、线程状态

1.五大状态

  1. 创建状态
  2. 就绪状态
  3. 运行状态
  4. 阻塞状态
  5. 死亡状态

如图所示：
在这里插入图片描述

2.停止线程

  1. 使用标志位方式

代码展示：

package com.wang.多线程;
public class StopThread_04 implements Runnable{
    // 设置标志位
    private boolean stop = true;
    @Override
    public void run() {
        int i = 0;
        while (stop) {
            System.out.println("Run...." + i);
        }
    }
    // 写一个标志位，用来停止某个线程
    public void stop() {
        this.stop = false;
    }
    public static void main(String[] args) {
        StopThread_04 stopThread = new StopThread_04();
        new Thread(stopThread).start();
        for (int i = 0; i < 500; i++) {
            System.out.println("main...." + i);
            if (i == 490) {
                // 调用stop方法停止线程
                stopThread.stop();
                System.out.println("run线程停止了");
            }
        }
    }
}
// 打印
main....0
Run....0
main....1
Run....0
main....2
Run....0
...
main....490
Run....0
run线程停止了

3.线程休眠（阻塞状态）

  1. PS:每一个对象都有一把锁，sleep不会释放锁
  2. sleep()的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

代码展示：

package com.wang.多线程;
import java.text.SimpleDateFormat;
import java.util.Date;
// 线程休眠
public class ThreadSleep_05 {
    public static void main(String[] args) throws InterruptedException {
//        ThreadSleep_05.tenDown();  // 这个方法是模拟倒计时
        // 模拟打印系统当前时间
        Date Time = new Date(); // 获取当前时间
        while (true) {
            Thread.sleep(1000); // 休眠1秒
            long time = Time.getTime(); // 将时间转换为long类型
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss"); // 将获取的时间格式化
            String format = simpleDateFormat.format(time); // 将long类型的时间转换为字符串形式
            System.out.println(format);
            Time = new Date(); // 从新获取时间起到更新时间的作用
        }
    }
    // 模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 30;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}
// 打印
14:05:04
14:05:05
14:05:06
14:05:07
14:05:08
14:05:09
14:05:10
14:05:11
即休眠一秒

4.线程礼让

  1. 首先礼让是不一定成功的
  2. 礼让线程，让当前正在执行的线程暂停，但不阻塞
  3. 将线程从运行状态转为就绪状态

代码展示：

package com.wang.多线程;
public class ThreadYield_06 implements Runnable{
    public static void main(String[] args) {
        ThreadYield_06 threadYield = new ThreadYield_06();
        new Thread(threadYield, "轿车").start();
        new Thread(threadYield, "货车").start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始");
        Thread.yield(); // 线程礼让方法
        System.out.println(Thread.currentThread().getName() + "线程结束");
    }
}
// 打印情况1：礼让成功
货车线程开始
轿车线程开始
货车线程结束
轿车线程结束
// 礼让不成功
轿车线程开始
轿车线程结束
货车线程开始
货车线程结束

5.合并线程(插队)

  1. 顾名思义插队就是有些线程它需要优先去执行

代码展示：

package com.wang.多线程;
public class ThreadJoin_07 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip插队" + i);
        }
    }
    public static void main(String[] args) {
        ThreadJoin_07 threadJoin = new ThreadJoin_07();
        Thread thread = new Thread(threadJoin);
        thread.start();
        for (int i = 0; i < 500; i++) {
            if (i == 150) { // 当i= 150 时，开始插队，插队线程执行完另一个才会继续
                try {
                    thread.join(); // 插队方法
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main" + i);
        }
    }
}
// 打印
main149
vip插队64
vip插队65
vip插队66
vip插队67
....
vip插队997
vip插队998
vip插队999
main150
main151

6.观察状态

代码展示：

package com.wang.多线程;
public class StateThread_08 {
    public static void main(String[] args) {
        Thread thread = new Thread( () -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(">>>>>>>>>>>>>");
        });
        // 观察状态
        Thread.State state = thread.getState();
        System.out.println(state);  // NEW 尚未启动的线程处于此状态。
        // 观察启动后
        thread.start(); // 启动线程
        state = thread.getState();
        System.out.println(state); // RUNNABLE 在Java虚拟机中执行的线程处于此状态。
        while (state != Thread.State.TERMINATED) { // 只要线程不终止，就一直输出
            try {
                Thread.sleep(100);
                state = thread.getState(); // 更新线程状态
                System.out.println(state);  //  TIMED_WAITING  线程处于阻塞（等待）状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

四、线程优先级

1.线程优先级

  1. 优先级一共分为1-10 越大级别越高 默认情况下为5
  2. 最重要的一点，并不是一定高的就执行快。线程的优先级和执行顺序无关

代码展示：

package com.wang.多线程;
public class ThreadPriority implements Runnable{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() +
                "--->" + Thread.currentThread().getPriority());
        ThreadPriority threadPriority = new ThreadPriority();
        Thread thread1 = new Thread(threadPriority);
        Thread thread2 = new Thread(threadPriority);
        Thread thread3 = new Thread(threadPriority);
        Thread thread4 = new Thread(threadPriority);
        Thread thread5 = new Thread(threadPriority);
        Thread thread6 = new Thread(threadPriority);
        // 设置优先级
        thread1.start();
        thread2.setPriority(5);
        thread2.start();
        thread3.setPriority(9);
        thread3.start();
        thread4.setPriority(10);
        thread4.start();
        thread5.setPriority(2);
        thread5.start();
        thread6.setPriority(3);
        thread6.start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
                "--->" + Thread.currentThread().getPriority());
    }
}
// 打印
main--->5
Thread-0--->5
Thread-2--->9
Thread-1--->5
Thread-3--->10
Thread-5--->3
Thread-4--->2
由此可以看出10级并没有第一个执行完

后记

本文下接：【多线程】一文搞懂Java多线程，代码示例，清晰明了（下）
Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/154224.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！