JUC并发编程-01：线程基础知识和常用方法

已于 2024-07-05 10:40:20 修改
阅读量155 收藏
点赞数 2
分类专栏： JUC并发编程 文章标签： java 开发语言
于 2024-06-14 00:41:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43216437/article/details/139667235
版权

线程基础知识和常用方法

JUC开发基础知识

先有进程，然后进程可以创建线程，线程是依附在进程里面的，线程里面包含多个协程

进程之间不共享全局变量，线程之间共享全局变量(线程通信就是用的这个，线程之间可以共享全局资源)

进程、线程、协程

进程就是一个应用单元、一个进程由多个线程组成。线程是CPU调度的基本单位。协程由java19新出也就是虚拟线程。
在这里插入图片描述

  • 并行、并发、串行
    并发：CPU上下文切换交替执行 并行：多核CPU同时执行任务

CPU核心数和线程数的关系

在这里插入图片描述

上下文切换

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

start和run

start方法会启动一个线程，程序会异步执行。而执行run方法不会启动一个线程，代码还是同步执行。

sleeep

线程睡眠方法。在以后的代码中推荐使用：TimeUnit.SECONDS.sleep(1);
在这里插入图片描述

在where（true）循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用CPU资源。

让步和优先级

Thread.yield()，方法的作用：暂停当前正在执行的线程对象，并执行其他线程。

  • yield()做的是让当前运行的线程回到可运行状态，以允许具相同优先级的其他线程获得运行机会。因此使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield达到让步目的。

yield()方法并不能保证线程一定会让出CPU资源，它只是一个提示，告诉线程调度器当前线程愿意让出CPU资源。具体是否让出CPU资源，还是由调度器决定。(如果CPU资源不紧张，一般也不会让出，如果CPU资源紧张，调度器收到让步通知后，会将占有资源优先分给其他同优先级线程)

public class Test {
    public static void main(String[] args) {
        Runnable task1=new Task1();
        Runnable task2 =new Task2();

        Thread t1=new Thread(task1);
        Thread t2=new Thread(task2);

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

   static class Task1 implements Runnable{

        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("A:"+i);
            }
        }
    }

   static class Task2 implements Runnable{

        public void run() {
            for (int i = 0; i < 6; i++) {
                Thread.yield();
                System.out.println("B:"+i);
            }
        }
    }
}

优先级

t1.setPriority(Thread.MAX_PRIORITY);，设置线程执行优先级，数字越大优先级越高和yield一样，也是通知线程调度器，如果CPU资源空闲一般会优先执行，如果CPU资源紧张，如果没有其他线程让出资源的情况下也只能干等着。

public class Test {
    public static void main(String[] args) {
        Runnable task1=new Task1();
        Runnable task2 =new Task2();

        Thread t1=new Thread(task1);
        t1.setPriority(Thread.MAX_PRIORITY);
        Thread t2=new Thread(task2);

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

   static class Task1 implements Runnable{

        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("A:"+i);
            }
        }
    }

   static class Task2 implements Runnable{

        public void run() {
            for (int i = 0; i < 6; i++) {
                Thread.yield();
                System.out.println("B:"+i);
            }
        }
    }
}

打断线程

正在睡眠的线程被打断，会报java.lang.InterruptedException异常

public class Sleep {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("睡眠结束");
        });

        t1.start();
        t1.interrupt();
    }
}
  • 打断线程
    在这里插入图片描述静态方式会清除打断标记，此时如果中断正在执行的线程，则撤销打断代码不会报异常。对象方法不会清除打断标记，撤销打断，还是会报异常

撤销打断

public class Sleep {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            try {
                Thread.interrupted();
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("睡眠结束");
        });

        t1.start();
        t1.interrupt();
    }
}
  • 对象方法不会撤销打断，清除打断标志
@Slf4j
public class Sleep {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("睡眠结束");
        });

        t1.start();
        log.info(t1.isInterrupted()+"");
        t1.interrupt();
        log.info(t1.isInterrupted()+"");
    }
}

线程中断

interrupt()方式会中断线程。仅仅是设置线程的中断状态为ture，不会停止线程。在这里插入图片描述

  • 代码证明
public class Sleep {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("定时监控");
            }
        });

        t.start();
        t.interrupt(); //线程中断
        System.out.println(t.isInterrupted());
    }
}

线程手动中断

如果当前线程中断标记是true，则手动中断当前线程

public class Sleep {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("定时监控");

                //获取线程中断标记
                boolean interrupted = Thread.interrupted();
                //如何线程中断标记是true，则中断该线程
                if (interrupted){
                    break;
                }
            }
        });

        t.start();
        t.interrupt();
        System.out.println(t.isInterrupted());
    }
}
  • 需要特别注意和sleep配合使用的时候容易出现的问题
    当出现InterruptedException 会清除中断标记 设置成false，此时再手动中断线程是无法中断的
public class Sleep {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){

                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    //当出现InterruptedException 会清除中断标记  设置成false，此时再手动中断线程是无法中断的
                    e.printStackTrace();
                }
                System.out.println("定时监控");

                if (Thread.interrupted()) { //false
                    break;
                }
            }
        });

        t.start();
        t.interrupt();
        System.out.println(t.isInterrupted());
    }
}

解决方法：再次加上中断

public class Sleep {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){

                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    //当出现InterruptedException 会清除中断标记  设置成false，此时再使用静态方法手动中断线程是无法中断的
                    e.printStackTrace();
                    
                    //再次加上中断标记
                    Thread.currentThread().interrupt();
                }
                System.out.println("定时监控");

                if (Thread.interrupted()) {
                    break;
                }
            }
        });

        t.start();
        t.interrupt();
        System.out.println(t.isInterrupted());
    }
}

加入线程join()

作用：子线程执行完毕后，主线程才执行。比如t.join()后，t线程执行完毕，主线程才执行

public class Sleep {

    static int value=1;
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            value=10;
            System.out.println("线程runable");
        });

        t.start();

        try {
            //加入线程，t线程执行完毕才执行主线程，也就是t线程先执行并执行完毕后才执行主线程
            t.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println("主线程："+value);
    }
}

isAlive

线程是否存活

public class Sleep {

    static int value=1;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            value=10;
            System.out.println("线程runable");
        });

        t.start();
        System.out.println(t.isAlive()); //true
        t.join();
        System.out.println(t.isAlive()); //false，由于加入线程了,子线程已经执行完毕，此时线程不是存活状态，false
        System.out.println("主线程："+value);
    }
}

守护线程

守护线程会伴随所有普通线程，所有普通线程结束后，守护线程立马终结
在这里插入图片描述
在这里插入图片描述

public class Sleep {

    static int value=1;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("子线程："+i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.setDaemon(true); //设置t为守护线程
        t.start();
        System.out.println("主线程："+value);
    }
}

实现Callable实现线程

声明一个任务

public class ExcuteSumTask implements Callable<Integer> {

    int t=100;

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 1; i <= t; i++) {
            sum=sum+i;
        }
        return sum;
    }
}
  • 测试
    声明一个未来任务对象，将定义的任务放到任务对象中
public class Test {
    public static void main(String[] args) {
        Callable<Integer> excuteTask=new ExcuteSumTask();
        
        //定义一个未来任务对象
        FutureTask<Integer> task = new FutureTask<>(excuteTask);
        Thread t=new Thread(task);

        //启动线程
        t.start();
        try {
            //获得线程执行结果
            System.out.println(task.get());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}
极乐码农
关注
专栏目录
05-Java多线程并发编程JUC.pdf
09-16
以上知识点涵盖了Java多线程并发编程和JUC的基础与高级特性，从线程的状态、创建、启动、通信、同步机制，到线程池的使用和线程中断处理，再到线程核心特性的保障，以及锁机制的深入理解和应用。掌握这些知识点对于...
java高并发源码-java-concurrent:Java高并发，JUC，相关源码。1、马士兵高并发视频源码（听课时练习）
05-24
首先，我们来了解下Java并发编程的基础知识。在Java中，多线程主要通过Thread类和Runnable接口实现。创建线程有两种方式：一是继承Thread类并重写run()方法，二是实现Runnable接口并在实现类中定义run()方法。线程间...
JUC并发----多线程基础与常用API
Promise_J_Z
03-19 859
会打断当前的等待状态，如果需要锁的则会等待获取锁，如果不需要所得会进入就绪状态，等待获取时间片interrupt的作用。
JUC并发编程 01——多线程基础知识
qq_62767608的博客
11-30 1075
JUC并发编程 01——多线程基础知识
JUC并发编程进阶1：线程基础知识复习
云扬的博客
10-13 419
本文是尚硅谷JUC并发编程之线程基础知识复习章节的学习笔记，包括start方法解读、多线程相关概念、守护线程和用户线程等内容。
JUC高并发编程-线程基础知识
dream_xsj的博客
11-27 248
JUC高并发编程
Java核心技术之- 多线程并发-JUC总结-并发编程
Aili的博客
05-24 526
1. 线程基础线程的创建与启动方式- 线程生命周期管理- 线程的状态转换- 线程同步与互斥- 程优先级设置2. 线程间通信- synchronized 关键字及其实现原理- wait() ， notify() ，notifyAll()，join()方法的使用- Lock 和 Condition 的使用- volatile 关键字的使用 - 原子类的使用- ConcurrentHashMap 和 ConcurrentLinkedQueue 的使用- CountD
JUC并发编程与源码分析笔记02-线程基础知识复习
王劭阳的博客
11-26 594
如果用户线程全部结束意味着程序需要完成的业务操作已经结束了，守护线程随着JVM一同结束工作，方法必须在start()之前设置，否则报异常。
JUC并发编程-基础（一）
weixin_42784609的博客
04-18 637
博客说明：内容初稿为本人的学习笔记归纳整理，在此基础上加入了相关视频学习、相关书籍的理解、相关文章博客查阅及源码阅读。博客的编写已经尽量做到详尽，但免不了有纰漏和理解不到位的地方。发现博客的任何问题均可联系我 aboutwxf@163.com。
JUC并发编程面试题
weixin_45081813的博客
04-06 3363
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC并发编程-线程基础知识复习
qq_44850917的博客
01-12 429
JUC基础知识
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
Java JUC并发编程实例：守护线程与Synchronized锁
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1404
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 630
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 559
知识量决定了未来能走多远
Hex编码
最新发布
weixin_74305514的博客
10-13 98
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
Spring Boot 整合 Minio
cmh1008611的博客
10-09 928
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值