狂神多线程

最新推荐文章于 2023-07-19 20:23:29 发布
最新推荐文章于 2023-07-19 20:23:29 发布
阅读量267 收藏 4
点赞数
分类专栏： java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40826814/article/details/115854646
版权

学习视频参考链接：https://www.bilibili.com/video/BV1V4411p7EF?p=27

  • 线程简介
  • 线程的实现（重点）
  • 线程状态
  • 线程同步（重点）
  • 线程通信问题
  • 高级主题（重点）

文章目录

 `1、线程简介`

栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了`会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。`

String str = new String("hello");
  • 1上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。

在这里插入图片描述​
例子：

开车 + 打电话

吃饭 + 玩手机

这些动作都可以抽象为任务，虽然看起来一心二用，但人只有一个大脑，在一个时间片刻只能处理一个任务。

CPU 也是一样，面对多个任务，只能在一个时间片刻处理一个任务。

主线程调用 run 方法和调用 start 方法开启子线程的区别如下图所示。
在这里插入图片描述​

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

2、线程实现

线程的三种实现方式：

在这里插入图片描述​

2.1 继承 Thread 类，重写 run 方法

继承 Thread 类，重写 run 方法。创建这个类的对象，再调用 start() 即可

package com.sjmp.Thread01;

/**
 * @ClassName ThreadTest
 * @Description TODO
 * @Author sjmp1573
 * @Date DATE{TIME}
 */
public  class ThreadTest {

    // 继承 Thread 类并重写 run 方法
    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }

    public static void main(String[] args) {
        //创建一个线程
        MyThread thread = new MyThread();
        //启动线程
        thread.start();
    }
}
  • 下载文件需要在 pom.xml 中 commons io 包。

使用该方法下载网络图片。

package com.example.studyexample.duoxiancheng;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;


public class downLoad {

    public void download(String url, String name)  {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));//把一个url的东西给文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader 方法出现问题");
        }
    }
}

class TestThread2 extends Thread{
    private  String url;//线程参数
    private  String name;
    public TestThread2(String url,String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        downLoad downLoad = new downLoad();
        downLoad.download(url,name);
    }

    public static void main(String[] args) {
        TestThread2 test01 = new TestThread2("https://i-blog.csdnimg.cn/blog_migrate/e3ec5cd927003f72650fc2a7e5abd3b5.png#pic_center", "test01");
        TestThread2 test02 = new TestThread2("https://i-blog.csdnimg.cn/blog_migrate/e3ec5cd927003f72650fc2a7e5abd3b5.png#pic_center", "test02");
        TestThread2 test03 = new TestThread2("https://i-blog.csdnimg.cn/blog_migrate/e3ec5cd927003f72650fc2a7e5abd3b5.png#pic_center", "test03");

//        并开启线程
        test01.start();
        test02.start();
        test03.start();

    }

} 

2.2 继承 Runnable 接口，创建 Tread 对象

继承 Runnable 接口，创建 Tread 对象，传入实现类，开启 start 方法.

package com.sjmp.Thread01;
public class ThreadRunnableTest {
    public static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("I am a child thread --Runnable");
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        new Thread(thread).start();
        new Thread(thread).start();
    }
}

以上两种方式的比较：

继承 Thread 类

  • 子类继承 Thread 类具备多线程能力
  • 启动线程：子类对象 .start()
  • 不建议使用：避免 OOP 单继承局限性

实现 Runnable 接口

  • 实现接口 Runnable 具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，方便同一个对象被多个线程使用。

火车抢票实例：

Runnable 实现多线程，创造一个实列 ticketRunnable ，可共享给多个线程。

​

只有一个线程执行的原因是时间片不够一个程序用，如果扩大票数就会有其他线程，只有一个线程的时候不会有线程安全问题

问了票数较多的情况，提高执行的效率，我们让多个线程同时执行引入sleep，让当前线程放弃cpu进入超时等待状态（此状态先线程不会被分配内存）如下图

​

但是会存在超卖，原因是多个线程同时获取ticket=1这种值，所以我们枷锁如下图

​

发现还是存在超卖的情况，原因分析是因为多个线程同时执行while (ticket > 0) 所以我们要扩大所的范围

​

OK了

2.3 实现 Callable 接口（了解）

  1. 实现 Callable 接口，需要返回值类型
  2. 重写 call 方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService = Executor.newFixedThreadPool(1);
  5. 提交执行：Future result1 = ser.submit(1);
  6. 获取结果：boolean r1 = result.get()
  7. 关闭服务：ser.shutdownNow():
package com.sjmp.demo01;

import java.util.concurrent.*;

/**
 * @author: sjmp1573
 * @date: 2020/11/15 22:16
 * @description:
 */

public class ThreadByCallable implements Callable<Boolean> {

    //    网络图片地址
    private String url;
    //    保存的文件名
    private String name;

    public ThreadByCallable(String url,String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        //        进入线程后，会创建一个下载器，下载器通过 downloader 方法，传入 url 和 name 下载相应的资源
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+ name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        这是 TestThread2 类的主方法
//        创建三个继承 Thread 的子类
        ThreadByCallable test01 = new ThreadByCallable("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3796445054,4193265240&fm=26&gp=0.jpg", "test01");
        ThreadByCallable test02 = new ThreadByCallable("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1605454961548&di=c3b49cc5869f058a6cded1434ea56f85&imgtype=0&src=http%3A%2F%2Fpic1.win4000.com%2Fwallpaper%2F5%2F538ec3134b63b.jpg", "test02");
        ThreadByCallable test03 = new ThreadByCallable("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=2044644877,1766802492&fm=15&gp=0.jpg", "test03");


//        创建执行服务：
        ExecutorService service = Executors.newFixedThreadPool(3);

//       提交执行
        Future<Boolean> submit01 = (Future<Boolean>) service.submit(test01);
        Future<Boolean> submit02 = (Future<Boolean>) service.submit(test02);
        Future<Boolean> submit03 = (Future<Boolean>) service.submit(test03);

        boolean rs1 = submit01.get();
        boolean rs2 = submit02.get();
        boolean rs3 = submit03.get();

//        关闭服务
        service.shutdownNow();
    }
}


//下载器，这是一个类
class WebDownloader{
//    下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader 方法出现问题");
        }
    }
}

计时器

public class jishi {
    public static void main(String[] args) {
        int i=10;
        while (i>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Date date = new Date(System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName()+" "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date));
            i--;

        }
    }
}
yield方法(经过实验多次运行的结果不一致，主要是由调度器决定程序的执行)
class TestYield implements Runnable {
    int i = 100;

    @Override
    public void run() {
        while (i > 0) {
            System.out.println(Thread.currentThread().getName() + "开启了线程");
            Thread.yield();
            System.out.println(Thread.currentThread().getName() + "结束了线程");
            i--;
        }
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        Thread threadA = new Thread(testYield, "threadA");
        Thread threadB = new Thread(testYield, "threadB");
        threadA.start();
        threadB.start()；     
      System.out.println(Thread.currentThread().getName() + "x");    }
}

合并线程——Join()

Join 合并线程，待此thread线程执行完成后，再执行其他线程，其他线程阻塞。
可以想象成插队。

class  testq implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());

        }
    }

    public static void main(String[] args) throws InterruptedException {
        testq testq = new testq();
        Thread thread = new Thread(testq);
        //多线程执行时可以，多线程的内容可以不结束，其他线程也可以运行，但是如果不是多线程的代码， 
          代码必须按顺序执行完
        thread.start();
        for (int i = 0; i < 100; i++) {
            if (i==5)
            {
                thread.join();
            }
            System.out.println(Thread.currentThread().getName());

        }
    }
}
死锁
class t1 extends Thread{
    private Object lock;
    private Object lock2;
    t1(Object obj,Object lock2){
        this.lock=obj;
        this.lock2=lock2;
    }
    @Override
    public void run() {
        synchronized (lock2){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock){
                System.out.println(1);
            }
        }
    }
}

class t2 extends Thread{
    private Object lock;
    private Object lock2;
    t2(Object obj,Object lock2){
        this.lock=obj;
        this.lock2=lock2;
    }
    @Override
    public void run() {
        synchronized (lock){
            synchronized (lock2){
                System.out.println(1);
            }
        }
    }
}

class test4{
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2 = new Object();
        t1 thread1 = new t1(obj,obj2);
        t2 thread2 = new t2(obj,obj2);
        thread1.start();
        thread2.start();

    }
}

https://blog.csdn.net/LINBE_blazers/article/details/104374119  Java死锁及如何解决死锁

3.5 守护（daemon）线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录操作日志，监控内存垃圾回收等待…





  •  

    ​

    ​

    14. synchronized 关键字和 volatile 关键字的区别

  • volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。
  • volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。实际开发中使用 synchronized 关键字的场景还是更多一些。
  • 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
  • volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证
  • volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

  • ReentrantLock

    十三、多线程开发良好的实践

  • 给线程起个有意义的名字，这样可以方便找 Bug。

  • 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。

  • 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。

  • 使用 BlockingQueue 实现生产者消费者问题。

  • 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。

  • 使用本地变量和不可变类来保证线程安全。

  • 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。

  • ​

    ​
学习使我可乐
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程
hjh3132778226的博客
04-09 995
多线程 文章目录多线程一、多线程简介1.多任务2.多线程3.程序.进程.线程4.Process与Thread5.核心概念二、线程实现1.线程创建（三种方法）1.1继承Thread类(重要)案例1.2实现Runnable接口案例龟兔赛跑:1.3实现Callable接口（了解）好处1.4Thread和Runnable对比2.静态代理实现: 结婚案例总结好处3.Lamda表达式函数式接口的定义:练习:练习2:总结:三、线程状态1.线程五大状态:2.线程方法2.1停止线程案例:测试stop2.2线程休眠案例:模拟网
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
Java多线程机制（狂神版，附源代码）
LSP522的博客
05-16 600
Java体系的一个重要部分就是多线程。在JAVA程序中，线程的最普遍用途是允许Applet在接受用户输入的同时，在屏幕的另一部分显示动画。使用多线程可以编写出CPU最大利用率的高效程序，因为空闲时间保持最低。这对Java运行的交互式的网络互连环境是至关重要的。 package Thread; import java.awt.*; import java.awt.event.*; import java.applet.*; public class Counter1 extends App
2021.6.28 多线程【狂神系列】
dearand的博客
11-29 384
2021.6.28 多线程 什么是多线程： 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运算单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。 简单来说：线程是程序中一个单一的顺序控制流程；而多线程就是在单个程序中同时运行多个线程来完成不同的工作。 多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。多个线程是同一时间需要完成
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3267
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
狂神说多线程详解.rar
05-06
《狂神说多线程详解》是一份深入探讨多线程技术的资源包，其中包含了对多线程编程的详尽解析。多线程是现代计算机编程中的一个重要概念，尤其在处理高性能计算、并发操作以及实时系统时，多线程技术显得尤为重要。它...
狂神说Java-多线程课程全部代码.rar
11-26
《狂神说Java-多线程课程全部代码》是一个涵盖了Java多线程和并发编程的实战教程资源。这个压缩包包含了一系列的示例代码（如demo01），旨在帮助开发者深入理解和掌握Java中的多线程技术及其在并发环境中的应用。 ...
多线程，day2，B站狂神，代码Lesson.rar
10-16
"多线程，day2，B站狂神，代码Lesson.rar"这个资源可能是一个关于Java多线程的第二日课程，由B站（哔哩哔哩）上的一位知名编程讲师，也就是所谓的“狂神”，分享的教学材料，包含有实际的代码示例。 首先，我们来...
【狂神说Java】Java多线程详细笔记(全)
Martin-share的博客
01-13 634
【狂神说Java】Java多线程笔记
多线程讲解狂神说
weixin_44502509的博客
06-16 3748
多线程讲解 学无止境,不学习就会被社会淘汰。笔记总结自狂神说多线程讲解 基本概念 进程 进程就是执行程序的一次执行过程,它是一个动态的概念,式系统资源分配的单位 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位 线程 线程就是独立的执行路径 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程 main()称之为主线程,为系统的入口,用于执行整个程序 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排
多线程—狂神说
TiAmo的博客
07-10 226
1.什么是多线程 多任务：同时做多件事，边看电视变吃饭边听歌（但是实际上是分时进行的，大脑的处理速度很快） **多线程：**多条线路同时执行，比如打游戏你可以和你朋友同时开黑。 普通方法调用： 1.调用run()，此时只有主线程一条依次执行路径 2.调用start(),开启多线程，多条执行路径，主线程与子线程并行交替执行。 进程与线程 程序就是数据和指令的有序集合，其本身没有任何运行的含义，是静态的，而进程是动态的的程序。 而进程是执行程序的一次执行，它是动态的概念，进程是资源分配资源的单位 通常一个进
认识多线程（区别；优点；执行顺序；创建线程）
weixin_43660497的博客
05-01 167
1 static final int Count=10; //计算Count次 static final int Number=10_0000_0000; //Number个数字 2 static final int Count=10; //计算Count次 static final i...
狂神说多线程笔记
m0_51654746的博客
04-02 1021
进程与线程 进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的一次，线程是CPU调度和执行的单位 注：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器，如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。 多线程其实就是让不同的线程去操作同一个对象 线程创建 Thread class 继承Thread类(
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 808
狂神说Java学习笔记——多线程
狂神说多线程学习笔记整理（一）
指尖上的革新
08-02 338
1程序线程进程 程序： 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 进程： 是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位 线程： 通常一个进程可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位 注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核。如服务器。如果是模拟出来的多线程，在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换很快，所以就有同时执行的错觉 核心概念 线程就
多线程（根据B站狂神说视频教程进行整理）
ChenTalented的博客
02-15 204
多线程
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值