多线程学习

已于 2022-07-22 22:15:29 修改
阅读量215 收藏
点赞数
分类专栏： JavaSE 文章标签： 学习 java jvm
于 2022-07-01 12:03:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k1159/article/details/125322604
版权

基本概念

1、程序：一些列有组织的文件，封装操作系统的各种API，实现不同的效果
2、进程：程序在系统中的一次执行过程，是拥有资源的最小单位，不同进程之间相互独立
3、IP地址：唯一在网络上标识一台主机的位置
3、端口号:操作系统上定位一个进程，且一般不变
4、线程：同一个进程下共享资源，任务执行（系统调度）的基本单位
在这里插入图片描述
5、JDK中提供的线程库实际上利用OS提供的线程库进行二次封装。故JDK中唯一的进程不一定是OS中唯一的进程，可能好几个进程

创建线程

java.long.Thread
【Java一切皆对象–线程对象–Thread类】
【Thread.activeCount()目前只在执行的线程数量，要-1出去后台进程】
1、多线程的创建
①继承Thread类覆写run方法
产生线程对象

public class Test1 {
    private static class MyThread extends Thread{
        @Override
        public void run() {//JVM调用run方法
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        MyThread m2 = new MyThread();
        MyThread m3 = new MyThread();
        m1.start();//启动线程
        m2.start();
        m3.start();
        System.out.println(Thread.currentThread().getName());
    }
}

②实现Runnable接口，覆写run方法
产生任务对象

public class Test2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread());
        Thread t2 = new Thread(new MyThread());
        Thread t3 = new Thread(new MyThread());
        t1.start();
        t2.start();
        t3.start();
        System.out.println(Thread.currentThread().getName());
    }
}

class MyThread implements Runnable {//不是线程实体，是线程任务

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

推荐使用②，实现接口更加灵活，子类还能实现别的接口，继承别的类
方式①只能继承Thread类，造成单继承局限

【使用匿名内部类和lambda表达式创建线程】

public class Test3 {
    public static void main(String[] args) {
        Thread t1 = new Thread("继承Thread类") {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }, "实现Runnable接口");
        Thread t3 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        }, "使用lambda表达式实现Runnable接口");
        t1.start();
        t2.start();
        t3.start();
        System.out.println(Thread.currentThread().getName());
    }
}

③实现callable接口，覆写call方法
④使用线程池创建线程
【多线程应用场景】

把一个大任务拆分为多个子任务，多个子线程并发执行，提高系统的处理效率

Thread类

1、构造方法
在这里插入图片描述

public class ThreadName {
    public static void main(String[] args) {
        Thread t1 =new Thread();
        Thread t2 =new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });
        Thread t3 = new Thread("小丑线程");
        Thread t4 = new Thread(new Runnable() {//常用
            @Override
            public void run() {

            }
        },"蝙蝠侠线程");
    }
}

2、核心属性
在这里插入图片描述
3、线程中断–通信方式
【中断一个正在执行的run方法还没结束的线程】
①线程中断的两种方式
1）通过共享变量进行中断

  /**
     * 通过共享变量中断线程
     */
    private static class MyThread extends Thread {
        volatile boolean isQuit = false;//此关键字保证可见性

        @Override
        public void run() {
            while (!isQuit) {
                System.out.println("进行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "被中断了");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        System.out.println("子线程开始");
        myThread.start();
        Thread.sleep(1000);
        myThread.isQuit = true;
        System.out.println("停止子线程");
    }

在这里插入图片描述

2）使用 Thread.interrupted()静态方法 或者 Thread对象的成员方法isInterrupted()

public class Test5 {
    private static class MyThread implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {//成员方法
                //while (!Thread.isInterrupted()) {   ---静态方法
                System.out.println(Thread.currentThread().getName() + "正在进行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);//被中断后抛出中断异常
 //抛出异常之后，中断状态会被清除
                    System.out.println("被中断了");
                    break;
                }
            }
            System.out.println(Thread.currentThread().getName() + "被中断了");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new MyThread(),"小丑");
        System.out.println("子线程开始");
        t1.start();
        Thread.sleep(5000);
        System.out.println("该停止了");
        t1.interrupt();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
【Thread.isInterrupted()与Thread.currentThread().isInterrupted()之间的区别】

public class Test6 {
    private static class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.interrupted());//清除中断标志
                /**
                 * 运行结果
                 * true
                 * false
                 * false
                 * false
                 * false
                 * false
                 * false
                 * false
                 * false
                 * false
                 */
            }
        }
    }
    private static class MyThread1 implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().isInterrupted());//不会清除中断标志，判断而已
                /**
                 * true
                 * true
                 * true
                 * true
                 * true
                 */
            }
        }
    }
    public static void main(String[] args) {
//        Thread t1 = new Thread(new MyThread());
//        t1.start();
//        t1.interrupt();
        Thread t2 =new Thread(new MyThread1());
        t2.start();
        t2.interrupt();//修改指定线程的状态为中断状态
    }
}

【修改指定线程的状态为中断状态—调用线程interrupt方法】
【Thread类的静态方法和成员方法isInterrupt作判断】
在这里插入图片描述
4、等待
join（）方法，在哪调用在哪等待（阻塞状态）
【也是进程之间通信的一种方式】
在这里插入图片描述
5、休眠
sleep（）
【sleep和yield方法不会百分百刷新工作内存读取主存】
6、线程状态
在这里插入图片描述
创建态：new
就绪态：ready
运行态：running（就绪和运行都是RUNNABLE）
终止态：terminated
阻塞态：（TIMED_WAITING BLOCKED WAITING）

在这里插入图片描述
在这里插入图片描述
7、线程状态转换
在这里插入图片描述
notify（） 唤醒
yiele()方法 让出CPU，从运行态进入就绪态等待CPU调度–OS调度程序员无法选择
【使用不多无法控制】
【一个线程创建后只能启动一次】

callable接口

【submit（）可以接收Rannable或者callable接口】
在这里插入图片描述
在这里插入图片描述

public class Callable_Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //接收call方法返回值使用FutureTask类
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        //启动callable接口还是得使用thread类的start方法，且必须通过FutureTask类
        Thread t1 = new Thread(futureTask);
        t1.start();
        int result = futureTask.get();//使用get方法会阻塞，直到call方法执行完毕
        System.out.println(result);
    }
}

线程安全问题

** 1、什么是线程不安全？**
A：多个线程串行和并发执行的结果不同，称为线程不安全
2、保证线程安全三个特性
A：原子性 -------------------一个操作一次执行完不会被中断
可见性 -----------------------一个线程对共享变量的修改，能够及时被其他线程看到
防止指令重排 ---------------代码的书写顺序不一定是最终JVM或者CPU的执行顺序
在这里插入图片描述

Java的内存模型

【描述多线程场景下，Java线程内存（高速缓存和寄存器）和主内存之间的关系】
在这里插入图片描述
在这里插入图片描述

synchronized关键字—线程上锁–锁的是对象

【满足可见性和原子性】
【在变量或者方法上使用synchronized】
【监视器锁–monitor lock（对象锁）】

锁

【锁的是对象】
特性：
1、互斥----mutex lock 某个线程获取到该对象的锁时，其他线程也要获取同一个对象的锁时，处于阻塞等待状态
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、synchronized代码块刷新内存
在这里插入图片描述
在这里插入图片描述

3、可重入
【Java中的线程安全锁都是可重入的，包括java.concurrent.lock】
【获取到对象锁的线程可以再次加锁】
【若不支持可能会造成死锁】

【当synchronized锁的是静态方法，相当于将此方法的类的所有对象都锁了（锁的是类名.class对象 全局唯一）】
在这里插入图片描述
【锁的优化都是在优化锁的力度】

juc下的常见子类

对象锁Lock

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

public class Lock_Test {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            lock.lock();//加锁
            System.out.println("加锁成功-----");
            try {
                System.out.println(Thread.currentThread().getName() + "获取到锁，其他线程等待");
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();//解锁
            }
            System.out.println("解锁成功-----");
        }, "小丑");
        t1.start();
        Thread t2 = new Thread(() -> {
            boolean isLocked = false;
            try {
                isLocked = lock.tryLock(3000, TimeUnit.MICROSECONDS);//代表千分之一毫秒的时间单位
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (isLocked) {
                    lock.unlock();
                }
            }
            System.out.println(Thread.currentThread().getName() + "不找你了，回去吃饭！");
        }, "蝙蝠侠");
        t2.start();
    }
}
lock与synchronized区别

在这里插入图片描述

死锁

【锁对象的循环等待问题】

产生死锁的原因

在这里插入图片描述

如何避免死锁

【可以使用jconsole检测死锁】
【破坏循环等待条件】

concurrent类

信号量Semaphore

【p-- 申请资源操作】【acquire()】
【v–释放资源操作】【release()】
【pv操作都是原子性的】
【每次申请和释放都是相同资源数】

public static void main(String[] args) {
        //构造参数传入可用资源的个数
        Semaphore semaphore = new Semaphore(5);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + "准备申请资源");
                    //P操作申请一个资源，无参默认
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "获取成功");
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "释放资源");
                    //v操作，释放一个占有的资源
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
    }

计数器CountDownLatch–大号join

【countDown() —计数器-1】
【await() 等待计数器为0】

public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);//10表示等待数量
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println(Thread.currentThread().getName() + "到达");
                    latch.countDown();//当一个进程到达，计数器减一
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable, "运动员" + i + 1);
            t.start();
        }
        //main宪政就是裁判线程，需要等待所有运动员到达重点再恢复执行
        //当countDown方法将计数器减为0则继续执行
        latch.await();
        System.out.println("所有运动员均已到位");
    }

循环栅栏 CyclicBarrier–自己了解补充

两个线程交换器 Exchanger–自己了解补充

线程安全类

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

volatile关键字

在这里插入图片描述
【只能保证可见性，不能保证原子性】
【内存屏障，防止指令重排】
在这里插入图片描述

等待与唤醒

【wait和notify是Object类的方法，用于线程的等待与唤醒，必须搭配synchronized锁使用】

等待方法

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

唤醒方法

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

蕾姆的48六
关注
专栏目录
多线程的学习资料（对初学者特别有用）！
09-04
多线程的学习资料（对初学者特别有用）！里面详细讲了有关线程池、以及相关的疑难杂症的相应解答。。。
多线程学习笔记
03-18
多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...
C#的多线程（2）——机制探索
孤剑之家
02-25 2950
注：本文中出现的代码均在.net Framework RC3环境中运行通过 　　一.多线程的概念 　　Windows是一个多任务的系统，如果你使用的是windows 2000及 其以上版本，你可以通过任务管理器查看当前系统运行的程序和进程。什么是进程呢？当一个程序开始运行时，它就是一个进程，进程所指包括运行中的程序和程序 所使用到的内存和系统资源。而一个进程又是由多个线
多线程教程、学习笔记
zhou870498的博客
04-13 1936
一、线程与进程的区别把操作系统的多个任务称为进程(Process)，而程序中的多任务则称为线程。一个程序运行后至少有一个进程，一个进程中可以包含多个线程。二、程序运行原理分时调度 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。抢占式调度 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。三、创建线程    方式一...
多线程学习资料
weixin_33840661的博客
05-27 96
2019独角兽企业重金招聘Python工程师标准>>> ...
labview多线程学习
09-03
多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**：线程是程序中的执行单元，一个进程可以包含一个或多个线程。在LabVIEW中，多线程允许同时执行多个任务，实现程序的并行处理，提高系统的响应速度和整体...
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
java多线程学习
11-27
在学习Java多线程的过程中，理解线程与进程的概念是非常基础且重要的一步。首先，进程是一个程序的执行实例，是操作系统资源分配的基本单位，具有独立的地址空间和运行状态。每个进程至少包含一个线程，我们称之为...
多线程学习汇总资料，多线程学习汇总资料，
04-13
多线程学习汇总资料，多线程学习汇总资料，多线程学习汇总资料，多线程学习汇总资料，多线程学习汇总资料，多线程学习汇总资料，
多线程学习资料-详细图解
03-05
学习多线程时总结的资料，利用活动图详细地画出了线程运行时的各种状态
（原创）学习资料-多线程相关
Android_xiong_st的博客
09-03 167
资料来源：黑马java视频 线程的几种状态： 参考博客 参考视频 一共六种 NEW：初始化态 线程被创建 RUNNABLE：运行态 又分为就绪状态和运行中两个状态 BLOCKED：阻塞态 线程阻塞于锁，在外面等待的时候称为阻塞态 WAITING：等待状态 拿到锁后发现不符合运行条件，需要暂停执行（比如调用wait让出锁，或者condition.await()） 让出cpu资源 供其他线程执行 TIMED_WAITING：超时等待 等待固定时间，在时间到达后自行返回 相比于等待状态需要其他条件唤醒，这个状态可
多线程资料
m0_63058236的博客
03-22 169
多线程多线程概述线程与进程同步与异步继承Thread实现RunnableThread类设置和获取线程名称线程休眠Sleep线程阻塞线程的中断守护线程（Daemon Thread）创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 多线程概述 现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，例如： 假设我们有语文、数学、英语3门作业要做，每个作业需要30分钟
java多线程编程学习资料
一枝会思想的芦苇的博客
02-18 166
Java多线程编程实战指南-核心篇(黄文海著)
多线程学习笔记一
奔跑的路
07-31 569
原文地址：多线程学习笔记一作者：吃鱼的小花猫 CreateThread, AfxBeginThread，_beginthread, _beginthreadex的区别 CreateThread是Windows的API函数(SDK函数的标准形式, 直截了当的创建方式，任何场合都可以使用)，提供操作系统级别的创建线程的操作，且仅限于工作者线程。不调用MFC和RTL的函数时，可以用 CreateThr
java多线程学习资料网站集合
shancoder的专栏
10-04 810
最近找工作，一直在看多线程，发现了一个 http://www.cnblogs.com/skywang12345/p/java_threads_category.html
shader 案例学习笔记之将坐标系分成4个象限
最新发布
localhost
09-13 120
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
多线程学习笔记：概念与初步实践
"关于多线程学习总结" 在计算机科学中，多线程是并发执行的编程模型，允许程序在同一时间处理多个任务。这种技术尤其在需要优化资源利用和提高响应速度的应用中至关重要。多线程使得程序员能够在一个进程中创建多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值