12 多线程

最新推荐文章于 2022-10-08 15:23:53 发布
最新推荐文章于 2022-10-08 15:23:53 发布
阅读量301 收藏
点赞数
分类专栏： JavaSE笔记-狂神 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46307478/article/details/122204248
版权

一.线程简介

普通方法调用和多线程

image-20211025142950214

**程序：**程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

**进程：**执行程序的一次执行过程，是一个动态的概念。进程是系统资源分配的单位。

**线程：**进程的一个执行单元，在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

进程和线程的区别

  • 地址空间：线程共享本进程的地址空间，而进程之间是独立的地址空间。

  • 资源：线程共享本进程的资源如内存、I/O、cpu等，不利于资源的管理和保护，而进程之间的资源是独立的，能很好的进行资源管理和保护。

  • 健壮性：多进程要比多线程健壮，一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。

  • 执行过程：每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口，执行开销大。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，执行开销小。

  • 可并发性：两者均可并发执行。

  • 切换时：进程切换时，消耗的资源大，效率高。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程。

注意：很多多线程都是模拟出来的，真正的多线程指有多个CPU，即多核，如服务器。如果模拟出来的多线程，即在一个CPU的情况下，在同一时间，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

核心概念：

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

二、线程创建

1.三种创建方式

  • Thread class 继承Thread类（重点）
  • Runnable 实现Runnable接口（核心）
  • Callable接口 实现Callable接口
创建方式一：继承Thread类
  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程执行对象，调用start()方法启动线程

注意：直接调用run方法和调用start的区别：run只有主线程一条路径；start多条执行路径

image-20211025142950214

package com.song.demo01;


//创建线程方式一：继承Thread类，重写run方法，调用start方法执行
public class TestThread01 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看代码。。。"+i);
        }

    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建子线程对象
        TestThread01 testThread01 = new TestThread01();
        //调用start方法开启线程,不能调用run
        testThread01.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习。。。"+i);
        }
    }
}

示例：多线程下载网络图片

package com.song.demo01;

import org.apache.commons.io.FileUtils;

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

//练习Thread，多线程同步下载图片
public class TestThread02 extends Thread{

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

    //构造器
    public TestThread02(String url,String name){
        this.url=url;
        this.name=name;
    }

    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件："+name);
    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://profile.csdnimg.cn/1/3/B/3_li1325169021","1.jpg");
        TestThread02 t2 = new TestThread02("https://csdnimg.cn/release/blogv2/dist/pc/img/newHealthCompanies1Active.gif","2.gif");
        TestThread02 t3 = new TestThread02("https://csdnimg.cn/medal/qiandao5@240.png","3.png");

        //同时启动三个线程，同时执行，完成的先后顺序并不一定相同
        t1.start();
        t2.start();
        t3.start();

    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            //借助一个外部工具类的方法，把一个url变成一个文件
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO 异常，downloader方法出现异常");
            //Ctrl+Alt+T捕获一下异常
        }
    }
}
创建方式二：实现类Runnable接口
  1. 定义MyRunnable类实现Runnable接口
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程

image-20211130221421034

package com.song.demo01;

//创建线程方式二：实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start方法
public class TestThread03 implements Runnable {

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看代码。。。" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建Runnable接口的实现类对象
        TestThread03 testThread03 = new TestThread03();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread03);
        thread.start();
        //前两行简写
        //new Thread(testThread03).start();



        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习。。。" + i);
        }
    }
}

示例：多线程下载图片

package com.song.demo01;

import org.apache.commons.io.FileUtils;

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

//练习Thread，多线程同步下载图片
public class TestThread02 implements Runnable{

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

    //构造器
    public TestThread02(String url,String name){
        this.url=url;
        this.name=name;
    }

    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件："+name);
    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://profile.csdnimg.cn/1/3/B/3_li1325169021","1.jpg");
        TestThread02 t2 = new TestThread02("https://csdnimg.cn/release/blogv2/dist/pc/img/newHealthCompanies1Active.gif","2.gif");
        TestThread02 t3 = new TestThread02("https://csdnimg.cn/medal/qiandao5@240.png","3.png");

        //同时启动三个线程，同时执行，完成的先后顺序并不一定相同
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            //借助一个外部工具类的方法，把一个url变成一个文件
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO 异常，downloader方法出现异常");
            //Ctrl+Alt+T捕获一下异常
        }
    }
}
小结

1.继承Thread

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

2.实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
创建方式三：实现Callable接口
  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Excutors.newFixedThreadPool(1)
  5. 提交执行：Future result1=ser.submit(t1);
  6. 获取结果：boolean r1=result1.get()
  7. 关闭服务：ser.shutdownNow();
package com.song.demo02;

import java.util.concurrent.*;

import org.apache.commons.io.FileUtils;

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


//线程创建方式三，实现Callable接口
/*
可以定义返回值
可以抛出异常
 */
public class TestCallable implements Callable <Boolean>{

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

    //构造器
    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }

    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://profile.csdnimg.cn/1/3/B/3_li1325169021","1.jpg");
        TestCallable t2 = new TestCallable("https://csdnimg.cn/release/blogv2/dist/pc/img/newHealthCompanies1Active.gif","2.gif");
        TestCallable t3 = new TestCallable("https://csdnimg.cn/medal/qiandao5@240.png","3.png");

        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);//new了一个池子，放了三个线程

        //提交执行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);

        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();

        //关闭服务
        ser.shutdown();

    }

}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            //借助一个外部工具类的方法，把一个url变成一个文件
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO 异常，downloader方法出现异常");
            //Ctrl+Alt+T捕获一下异常
        }
    }
}

2.并发问题

一个有问题的示例：

package com.song.demo01;

//多个线程同时操作同一个对象
//买火车票的例子

public class TestThread04 implements Runnable{

    private int ticketNums =10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0)
                break;
            //模拟延时
            try{
                Thread.sleep(200);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"  拿到了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread04 ticket = new TestThread04();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"张三").start();
        new Thread(ticket,"李四").start();
    }
}

发现的问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

龟兔赛跑示例：

package com.song.demo01;

//模拟龟兔赛跑
public class Race implements Runnable {

    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName() == "兔子") {
                try {
                    Thread.sleep(10);//会抛出异常，Alt+Shift+Enter
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag) {
                break;
            }

            System.out.println(Thread.currentThread().getName() + "  跑了 " + i + "步");
        }
    }

    //判断比赛是否完成
    private boolean gameOver(int steps) {
        //已经存在胜利者了
        if (winner != null) {
            System.out.println("比赛结束");
            return true;
        } else {
            if (steps >= 100) {
                winner = Thread.currentThread().getName();
                System.out.println("Winner is" + winner);
                return true;
            } else {
                return false;
            }
        }
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();

    }
}

3.Lamda表达式

4.静态代理

静态代理模式总结:

  • 真实对象和代理对象都要实现同一个接口
  • 代理对象要代理真实角色

好处：

  • 代理对象可以做真实对象做不了的事情
  • 真实对象专注做自己的事情

对比线程代理与静态代理模式：

package com.song.demo03;
//静态代理模式总结
/*
真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
 */


public class StaticProxy {

    public static void main(String[] args) {
        You you = new You();//真实对象

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("w我爱你");
            }
        }).start();

        new Thread(()-> System.out.println("我爱你")).start();//上面的精简
        new WeddingCompany(new You()).HappyMarry();//下面两行的精简
        //总结：都是通过代理来代理真实对象，即线程的Runnable接口实现也是代理模式

        //通过代理角色来调用
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }


}

interface Marry{
    //
    void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("要结婚了，超级开心");
    }
}

//代理角色，帮助你结婚
class WeddingCompany implements Marry{

    //代理谁--->真实对象
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//实际结婚对象
        after();
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    private void after(){
        System.out.println("结婚之后，收尾款");
    }
}
气运2020
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JAVA核心知识】12：线程基础
积
04-26 210
定义 线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，同一进程中的多条线程将共享该进程中的全部系统资源。线程是独立调度和分派的基本单位。 – 百度百科 创建一个线程 继承Thread类 实现Runnable接口 ...
操作系统：12 线程竞争与线程池
snowysc的博客
05-11 898
线程竞争与线程池
重拾Java回忆录（十二）：Java12线程的使用
搓搓那年时光静好
01-20 1417
进程和线程 进程:一个操作系统中执行的一个子程序,包含虚拟cpu,代码,数据 DOS 多进程:一个操作系统中执行的多个子程序,提高cpu的使用率 线程:在一个进程中同时执行的子程序流 多线程:在一个进程中同时执行的若干的子程序流 进程和线程的区别: 进程有独立的进程空间(存放数据),彼此之间是独立的 线程的堆空间是共享的,栈空间是独立的,而且线程占用的资源比较小,相互之间可以影响
12.线程的引出与实现——核心级线程实现实例
jieqiong1的博客
01-22 524
1.从进入内核开始——从某个中断开始main() { // main先执行A，将B的开始地址压栈，即 A函数返回地址 是 B的开始地址 A(); B(); }A() { //进程由资源和执行序列组成，fork会创建资源和执行序列（线程） //fork 是 创建系统进程的调用，会引起中断，可能会引起 内核级线程 切换 fork(); }fork:
12--线程技术
QB哥欢迎您
04-17 433
1、多线程 1.1、多线程相关概念 1.1.1、进程 进程：在操作系统中运行的某个软件（主要是指在内存中）。任何软件要运行都要被加载到内存中。而内存负责运行这个软件所需要的那些内存空间，就被称为当前软件在内存中的一个进程。 使用任务管理器可以直接查看当前系统中运行着的各个进程： 1.1.2、线程 线程：软件运行之后真正负责执行软件中具体某个功能的那个独立的内存空间（它必须位于进...
Oracle 12c 新特性之多线程数据库操作
12-15
Oracle 12c引入了一项重要的新特性，即在Unix/Linux平台上支持多线程数据库操作。在此之前，Oracle数据库在这些操作系统上通常以多进程模式运行，每个连接都会创建一个新的进程。而在Windows环境下，Oracle采用多...
Halcon12+VisualStudio2013实现多线程
02-03
本文将深入探讨如何在Halcon12中结合Visual Studio 2013实现多线程技术，这对于提升图像处理速度和优化资源利用率至关重要。 首先，多线程是现代软件开发中的一个重要概念，它允许程序在同一时间执行多个独立的任务...
day12 多线程02.md
08-14
线程基础资料
多线程学习
03-08
在IT领域，多线程是程序设计中的一个重要概念，尤其在服务器端开发和高并发场景中，多线程技术能够有效利用系统资源，提高应用程序的响应速度和处理能力。本篇将深入探讨多线程的核心知识，以及它与Java集合和IO的...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
面试中常被问到（12）进程与线程的区别
AllenSquirrel
06-28 1557
什么是智能指针？ 智能指针的本质就是一个类，当超出类的作用域，类会自动调用析构函数，析构函数会自动释放资源，因此智能指针的目的就是当手动申请空间后在程序结束时会自动释放内存空间，不需要手动释放，即使忘记释放也会避免内存泄漏 常见智能指针： auto_ptr unique_ptr shared_ptr weak_ptr ...
多线程相关概念
cyming_的博客
10-08 553
程序是死的，静态的，是一些代码和数据经过编译后的二进制指令。一般对应于操作系统中的一个可执行文件，比如windows系统的exe文件，linux系统的elf文件进程是执行中的程序，是活的，她执行着程序中的一个一个指令。每个进程都是一个程序经历创建，运行和销毁的过程。进程特点：一个进程有独立的虚拟内存空间，映射到特定的物理内存空间。各个进程间不会相互干扰。一个进程在内存空间中分区: 有栈区、堆区、代码区和数据区等等操作系统何以同时运行多个进程，通过一定的调度算法使进程以为只有自己在独占cpu时间。
【12】-进程和线程定义，概念，区别详解
世上只有一种英雄主义
04-29 441
进程的定义及基本概念： 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。 组成 进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域...
Xeon可扩展Xeon睿频
charleslei的专栏
03-05 578
进行多线程AVX512运算的时候，需要把频率降下来，使用更低的电压，才能把功耗控制在一个TDP范围内——这就是全核AVX512默频；如果散热给力，可以提高电压增加点功耗，频率提高点——AVX512全核睿频。 进行多线程AVX2运算的时候，单个核心的功耗会降下来。同样的，把功耗控制在TDP范围内的是AVX2默频；散热给力的时候，适当提高电压增加功耗，频率更高——AVX2全核睿频。 进行多线程非A...
线程调度：你的电脑能同时做多少件事？
CliviaZ的博客
01-28 753
线程调度：你的电脑能同时做多少件事？线程 vs 进程进程线程你的电脑能同时做多少件事？线程调度的两种机制分时调度抢占式调度（Java中使用的调度机制） 线程 vs 进程 在进入正题之前，我们先来了解一下什么是线程。 线程是进程的执行路径，而进程就像是一个软件。如果一个进程里一个线程都没有了，那表示要执行的事情一件都没有了，那么这个进程也就马上要被关闭掉了。因此，我们先来详细介绍一下进程。 进程 进程可以简单理解为拥有独立内存空间的应用程序。 指一个内存中运行的应用程序，每个进程都有一个独立的内存空间（可
【转】cpu的核心数与线程数的关系
weixin_34082789的博客
02-11 1924
　　原文地址：http://www.dn580.com/dnzs/dncs/2013/10/08/172948914.html 　　我们在选购电脑的时候，CPU是一个需要考虑到核心因素，因为它决定了电脑的性能等级。CPU从早期的单核，发展到现在的双核，多核。CPU除了核心数之外，还有线程数之说，下面笔者就来解释一下CPU的核心数与线程数的关系和区别。 　　简单地说，CPU的核心数是指物理上，也...
四核8线程与八核的区别
lucky
11-14 3万+
四核八线程是指使用了超线程技术 , 把一个物理核心,模拟成 两个逻辑核心, 理论上要像八颗物理核心一样在同一时间执行八个线程，所以设备管理器和任务管理器中会显示出八个核心，但事实上并不是真正的八个核心，四核八线程就是真四核，虚拟八核； 四核八线程在有些情况下比如任务量不大能让CPU利用率提高很多从而使其性能接近八核CPU的水平，而在另外一些情况比如CPU占用100%满负荷工作的情况下，这时候
什么是多线程 菜鸟入门
x329357842的博客
12-23 1万+
网上很多资料对多线程都有详细的描述与理解，本菜鸟刚刚入门JAVA对多线程方面不是很熟悉，在看过很多视屏，以及相关博客，书籍通过自己的语言来描述对JAVA多线程的理解，给一些和我一样的菜鸟一起交流，写的不好的地方请各位大神多多指正，互相学习，共同进步。 1.什么是多线程？ 是指一个应用程序同时执行多个任务，一般来说一个任务就是一个线程 ，而一个应用程序有一个以上的线程我们称之为多线程。 2.什么
为什么要使用多线程？多线程的优点和缺点是什么？
热门推荐
音符的博客
07-03 5万+
首先说下多线程出现的原因: 为了解决负载均衡问题,充分利用CPU资源.为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不互相干扰.为了处理大量的IO操作时或处理的情况需要花费大量的时间等等,比如:读写文件,视频图像的采集,处理,显示,保存等 多线程的好处: 1.使用线程可以把占据时间长的程序中的任务放到后台去处理 2.用户界面更加吸引人,这样比如用户点击了一个按
stc 8a8k64s4a12 多线程执行
最新发布
05-24
STC 8A8K64S4A12 是一款基于8051内核的单片机，它本身并不支持多线程执行。但是可以通过编写多任务调度程序来实现类似多线程的效果。 一般来说，多任务调度程序的实现需要依赖于定时器中断和任务队列。具体的步骤...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值