多线程

最新推荐文章于 2021-12-25 11:45:46 发布
最新推荐文章于 2021-12-25 11:45:46 发布
阅读量164 收藏
点赞数
分类专栏： 努力学习upup 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D_Nky/article/details/108788462
版权

1. 概念

  • 进程：当一个程序正在运行时，就是一个进程
  • 线程：进程中的一个执行单元，负责控制进程的执行
  • 线程分为用户线程和守护线程
    一个程序至少有一个进程，一个进程可以有多个线程

2. 普通方法调用和多线程的区别

  • 普通方法的执行
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200925063632419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RfTmt5,size_16,color_FFFFFF,t_70#pic_center
  • 多线程的执行
    在这里插入图片描述

3. 实现多线程的三种方式

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口

3.1 Thread类

优点：编写简单，想要访问当前线程直接this就可以获取
缺点：线程类无法继承其他类

步骤：

  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
//继承Thread类，重写run()方法，调用start()方法
public class TestThread extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <10 ; i++) {
            System.out.println("学习");
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        TestThread testThread =new TestThread();
        testThread.start();

        for (int i = 0; i <200 ; i++) {
            System.out.println("写代码");
        }
    }

虽然在代码中是先让start()方法先执行的，但是输出的结果是main主线程先输出；
run()方法的输出结果穿插在中间，并且每次输出的位置不一样；
所以，线程开启时不一定会立即执行，由cpu调度执行

3.2 Runnable接口

优点：实现接口类，还可以继承其他类
缺点：编写稍复杂，如果想访问当前线程需要使用Thread.currentThread()方法

步骤：

  1. 实现Runnable接口
  2. 重写run()方法
  3. new Thread类，并把runnable接口实现类当作参数
  4. thread.start()启动线程
//Runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类
public class MyRunnable implements Runnable {
    public void run() {
        //run线程
        for (int i = 0; i <10 ; i++) {
            System.out.println("学习");
        }
    }

    public static void main(String[] args) {
    	//创建runnable接口实现类对象
        MyRunnable myRunnable=new MyRunnable();
        //创建线程对象，通过线程对象来开启线程
        Thread thread =new Thread(myRunnable);
        thread.start();
        for (int i = 0; i <100 ; i++) {
            System.out.println("写代码");
        }
    }
}

3.3 Callable接口

与Runnable接口不同点：

  • Runnable的重写方法是run(),Callable重写方法是call()
  • Callable有返回值，Runnable没有
  • call方法可以抛异常

步骤：

  1. 实现Callable接口，需要定义泛型类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(线程数量);
  5. 提交执行：Futrue<泛型类型> r1 = ser.submit(目标对象);
  6. 获取结果：boolean rs1 = r1.get();
  7. 关闭服务：ser.shutdownNow();

注:（ExecutorService是一个线程池接口，Executors有四种线程池）

public class MyCallable implements Callable<Boolean> {
    public MyCallable(String url,String file) {
        this.url=url;
        this.file=file;
    }

    String url;
    String file;
	//上面不用管，看下面的
	
	//call方法相当于Runnable接口中的run方法
    public Boolean call() throws Exception {
        WebDowload webDowload=new WebDowload(url,file);
        webDowload.dowloader();
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建目标对象
        MyCallable myCallable1 =new MyCallable("https://i0.hdslb.com/bfs/archive/622017dd4b0140432962d3ce0c6db99d77d2e937.png","D://1.png");
        MyCallable myCallable2 =new MyCallable("https://i0.hdslb.com/bfs/archive/622017dd4b0140432962d3ce0c6db99d77d2e937.png","D://2.png");
        MyCallable myCallable3 =new MyCallable("https://i0.hdslb.com/bfs/archive/622017dd4b0140432962d3ce0c6db99d77d2e937.png","D://3.png");

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

        //提交执行
        Future<Boolean> r1 = ser.submit(myCallable1);
        Future<Boolean> r2 = ser.submit(myCallable2);
        Future<Boolean> r3 = ser.submit(myCallable3);

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

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

4. 线程状态

  1. 创建状态：生成线程对象，没有启动，这是创建状态

  2. 就绪状态：线程对象在start开启之后就处于就绪状态，如果线程对象从等待或者睡眠结束之后也会变成就绪状态

  3. 运行状态：线程调度程序将处于"就绪状态" 的线程对象设置为当前线程，此时状态就变成了运行状态，并运行run()中的代码

  4. 阻塞状态：线程在运行时被暂停，sleep、suspend、wait等方法都可以导致线程阻塞

  5. 死亡状态：线程在run()方法结束之后，或者调用stop方法之后就进入死亡状态

阻塞的5种状态：

1. 线程休眠： Thread.sleep(long millis)参数为毫秒数

  • sleep(时间)指定当前线程的毫秒数；
  • sleep存在异常InterruptedException；
  • sleep时间达到后线程进入就绪状态；
  • sleep可以模拟网络延时，倒计时等；
  • 每一个对象都有一个锁，sleep不会释放锁；

2. 线程礼让： Thread.yield();让别的线程先运行，让当前线程暂停从运行状态变成就绪状态，但不进入阻塞状态，礼让不一定成功

3. 合并线程： thread.join();Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞，可以想象成插队

4.改变线程优先级：getPriority();获取线程优先级，返回值为int，setPriority(int i);设置线程优先级，参数为int

线程优先级最大值为10，最小值为1，标准值为5；
优先级低，不代表不会被调用，只是调用的概率变低了，都得看cpu的调度；
（注意要先设置优先级，再start）

public class TestPriority {

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1启动");
        },"线程1");
        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2启动");
        },"线程2");
        
        //设置线程优先级
        thread1.setPriority(1);
        thread1.start();
        System.out.println(thread1.getPriority());
        thread2.setPriority(10);

        thread2.start();
        System.out.println(thread2.getPriority());
    }
}

5.将线程设置成守护线程：thread.setDaemon(Boolean on)设置线程为守护线程，参数为布尔类型，true为设置成守护

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

当用户线程结束之后，守护线程也会自动结束

4.1 观测线程状态

Thread.State state = thread.getState();创建观测状态
state=thread.getState();更新状态，进入下一种状态的时候再获取一次

public class TestState {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread( () -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });
        //观察线程状态
        //New
        Thread.State state = thread.getState();//创建观测状态
        System.out.println(state);
        //启动线程
        thread.start();
        //Run
        state=thread.getState(); //更新状态
        System.out.println(state);

        while (state!=Thread.State.TERMINATED) {//只要线程不终止，就一直输出状态
        Thread.sleep(100);
        state=thread.getState();//更新状态
            //Terminated，线程终止
            System.out.println(state);
        }
    }
}

几种线程状态的输出结果：

  1. new: new Thread() 后处于新生状态,尚未启动
  2. Runnable: 在Java虚拟机中执行的线程处于此状态
  3. Blocked: 被阻塞,等待监视器锁定的线程处于此状态
  4. Waiting: 等待另一个线程执行特定动作的线程处于此状态
  5. Time_Waiting: 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
  6. Terminated: 退出的线程处于此状态

5. synchronized

使用线程同步可以保证安全性，但是会导致性能降低的问题

比如：

  • 一个线程持有锁会导致其他需要此锁的线程全部挂起；
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时
  • 如果优先级较高的线程等待一个优先级较低线程释放锁，会导致优先级倒置

synchronized可以使用在方法上和代码块中；

作用在方法上：

锁类的实例对象；

private synchronized void method(){}

锁类对象（即new多个实例对象，但他们仍然是属于同一个类依然会被锁住）；

private static synchronized void method(){}

作用在代码块中:

锁类的实例对象；

synchronized(this){
}

锁类对象

synchronized(SynchronizeDemo.class){
}

锁任意的object实例对象，（公共资源）

String lock;
synchronized(lock){
}

6. 死锁

两个（或多个）线程各自占有一些共享资源，并且互相等待对方线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题

产生死锁的四个必要条件：

  • 互斥条件：一个资源每次只能被一个线程使用
  • 请求与保持条件：一个线程因请求资源和阻塞时，对已获得的资源保持不放
  • 不剥夺条件：线程已获得的资源，在末使用完之前，不能强行剥夺
  • 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系

7. ReentrantLock

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 =new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    private int ticket = 10;
    //获取锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            //加锁
            lock.lock();
            Thread.sleep(1000);
            while (ticket>=0){
                System.out.println(ticket--);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }
}

8. synchronized与Lock的对比

  • Lock是显式锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的拓展性（提供更多的子类）
  • 优先使用顺序
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源 ）> 同步方法（在方法体之外）

9. 线程通信

并发协作模型“生产者 / 消费者模式”
必须在synchronized修饰的方法中

利用缓冲区解决（管程法）：
生产者发现仓库满了，则自己wait()，同时唤醒消费者notify()，如果仓库空了则唤醒自己；
消费者发现仓库空了，则自己wait()，同时唤醒生产者notify()，如果仓库满了则唤醒自己；

/**
 * 生产者消费者问题，创建缓冲区，管程法
 * */
public class TestPC {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        Producer producer = new Producer(container);
        Consumer consumer = new Consumer(container);
        new Thread(producer).start();
        new Thread(consumer).start();
    }

}

//生产者
class Producer implements Runnable{
    //拿到缓冲区;
    SynContainer container;
    
    Producer(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            //传入第i个产品
            try {
                //循环放入产品，并把id传进产品
                container.push(new Product(i));
                System.out.println("生产了第"+i+"个产品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Consumer implements Runnable{
    //拿到缓冲区;
    SynContainer container;

    Consumer(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            //获取第i个产品
            try {
                //获取产品类的id
                System.out.println("消费了第"+container.take().id+"个产品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//产品
class Product{
    //产品id
    int id;

    public Product(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //创建容器
    Product product ;
    Product[] products =new Product[100];
    int count=0;

    //生产者放入产品
    public synchronized void push(Product product) throws InterruptedException {
        //如果容器满了，通知消费者拿取产品
        if(count==products.length){
            //通知消费者拿取产品，生产者等待
            this.wait();
        }
        //如果容器未满，生产产品放入容器
        products[count]=product;
        count++;
        this.notify();

    }
    
    //消费者拿取产品
    public synchronized Product take() throws InterruptedException {
        //如果容器没产品，通知生产者生产
        if (count==0){
            //消费者等待，生产者生产
            this.wait();
        }
        //如果有产品，拿取产品
        this.notify();
        count--;
        Product product=products[count];
        return product;
    }
}

信号灯法： 创建一个布尔类型的标志位flag，如果为true，就让他等待、如果为false，就让他去通知另外一个人、把两人衔接起来

10. 线程池

为什么使用： 频繁的创建和销毁使用量大的线程，对性能影响很大

好处：

  • 提高响应速度，减少了创建新线程的时间
  • 降低资源消耗，重复利用线程池中的线程，不需要每次创建
  • 便于线程管理
    • corePoolSize：核心池的大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

10.1 使用线程池

  • JDK5.0提供了线程池相关的API：ExecutorService和Executors
  • ExecutorService： 真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute (Runnable command)Reunnable的线程池执行方法，没有返回值
    • <T> Future<T> submit (Callable<T> task)Callable接口的线程
    • void shutdown()关闭线程池
  • **Executors：**工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Ningkeyo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
项目体验：高并发httpclient和线程池的正确使用
蒲公英的约定
12-01 2万+
ExecutorService、Executors线程池使用不合理导致的性能问题
Python 使用多线程进行并发请求
Trb701012的博客
01-23 1704
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。为了加快请求的响应时间，我们可以使用多线程发送并发请求。
关于使用多线程批量请求的需求
Autism、陌亡
04-19 2868
1.需求背景    说句实话，在我参与的项目中，多线程用处不多，但确实用到了，有时候多线程用好了，的确能大大提高系统的性能与效率。这里我就举例我在项目中用到的需求，若有不当之处，还请多多指教。需求1：获取各个类型在各个时间段内的数据量获取结果通过Echarts展示如下图所示：      如果按正常流程编写接口也能查询到对应的数据，或者你会说总共最多9种类型，我可以new Thread9个多线程来同...
java网络编程____httpclient多线程请求和线程池
-
03-10 3614
import org.apache.http.HttpEntity; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.protocol.HttpClientConte...
httpclient 多线程高并发Get请求
热门推荐
Cumu Blog
10-21 2万+
最近公司需要对地址进行清洗，挑选了百度的LBS平台的Geocoding API v2接口，量级在千万级别。为了达到较高的效率，优化了下httpclient（版本：4.2.3）的get请求，具体的就是使用http的连接池，这样不需要每次get都需要3次握手，大大提高了并发能力，并且失败率降低了100倍，具体代码如下： public class HttpRequest {
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
多线程介绍
10-21
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多...
多进程和多线程请求实例
Jepson的博客
12-25 714
采用多线程和多进程请求网页 #coding=utf-8 import requests import time import threading import multiprocessing print('************************开始执行DDoS攻击************************') # time.sleep(2) def attack_work(name,num): count = 1 while True: if count
多线程请求第三方教育数据接口优化
hello world
04-16 8618
目录 一、需求 二、实现 三、分析 一、需求 Q:业务过程中遇到一个问题： 1.有一批数据，其中每个数据都需要请求第三方接口返回数据， 2.第三方没有批量请求接口， 3.请求返回的数据要返回给前端，对时效有要求。 以上，所以想用多线程批量调用对方接口，试着缩短接口响应时间。 二、实现 新建线程类实现callable接口 public class BatchCallTh...
java模拟多线程http请求
net343的博客
07-20 1万+
package test;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.concurrent.ExecutorService;import java.util.conc
每分钟有2K用户访问，服务器端处理请求选择用多线程（每个用户一个线程），还是用I/O复用？
yill_h的博客
11-02 3546
我只是一个搬运工，只为感兴趣的话题.  .  . 编程Linux计算机网络epoll多线程 Linux 开发，使用多线程还是用 IO 复用 select/epoll？ 每分钟有2K用户访问，服务器端处理请求选择用多线程（每个用户一个线程），还是用I/O复用？ 5 条评论  分享 默认
多线程实现并发请求
weixin_30496751的博客
08-24 952
多线程：不应该开太多，线程之间切换会消耗 编写方式　-直接返回处理 　　　　　-通过回调函数处理 v.add_done_callback(done) 线程是CPU的最小工作单元，线程共享工作资源 """ 可以实现并发 但是，请求发送出去后和返回之前，中间时期线程空闲 编写方式： - 直接返回处理 - 通过回调函数处理 """ ######...
Java多线程请求
qq_44800248的博客
09-26 598
ExecutorService service = Executors.newCachedThreadPool(); CountDownLatch countDownLatch = new CountDownLatch(objectList.size()); for (Object object:objectList) { service.execute(new Runnable() { @Sneaky...
Delphi学习案例.docx
最新发布
07-16
Delphi 是一个基于 Object Pascal 的高级编程语言和集成开发环境 (IDE)，适用于 Windows、macOS、iOS 和 Android 平台的快速应用程序开发 (RAD)。以下是一个简单的 Delphi 学习案例，展示如何使用 Delphi 开发一个基本的 Windows 应用程序，该应用程序将实现一个简单的记事本功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值