多线程基础详解

最新推荐文章于 2024-05-19 21:31:03 发布
最新推荐文章于 2024-05-19 21:31:03 发布
阅读量207 收藏 1
点赞数
分类专栏： 并发编程 文章标签： 多进程 thread 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46558851/article/details/112544326
版权

多线程基础

目录

一、初识多线程

普通方法和多线程：

在这里插入图片描述

进程process和线程thread

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

创建线程的方式

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

通过继承Tread类

实战演示：

package com.yan;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/12 18:57
 * @description：  单核cpu只能实现单线程，因为cpu执行速度很快，
 * 所以这里是视作为多线程，但是实际上还是交替执行的（由CPU调度实现），并不是一起执行的；
 * 但是由于这个时间很短很短，所以看起来可以是作为是同步执行的
 */
public class demo01 extends Thread{
    @Override
    public void run() {
        //run方法线程
        for (int i = 0; i < 20; i++) {
            System.out.println("run线程~~~~~~~~~~~~~~~~");
        }
    }

    public static void main(String[] args) {
        demo01 thread1 = new demo01();
        //这里相当于开辟了一条新的线程，但是默认会执行run方法
        thread1.start();
        //main主线程,两条线程是同时执行，交替执行的
        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程~");
        }
    }
}

搞完收工~

通过实现Runnable接口

在这里插入图片描述

package com.yan;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/12 19:53
 * @description：
 */
public class demo2 implements Runnable{
    @Override
    public void run() {
        //run方法线程
        for (int i = 0; i < 20; i++) {
            System.out.println("run线程~~~~~~~~~~~~~~~~");
        }
    }

    public static void main(String[] args) {
        //这里跟demo1里面的不一样，在Thread构造方法里面加入了Runnable参数
        new Thread(new demo2()).start();
        //main主线程,两条线程是同时执行，交替执行的
        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程~");
        }
    }
}

这里的Thread类也实现了Runnable接口~继承Thread的时候不一定非要重写run方法，是因为start（）方法的调用不得不使用run（）方法，没有目标target则无法用start（）方法，还有一种方法是实现Callable接口，但是用的不多，所以在这里就不演示了
在这里插入图片描述

数据冲突问题

package com.yan;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/14 20:08
 * @description：
 */
public class demo3 implements Runnable{
    private int tickName = 10;
    @Override
    public void run() {
        while (true) {
            if (tickName <= 0) {
                break;
            }
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->拿到了第" + tickName-- + "票");
        }
    }

    public static void main(String[] args) {
        demo3 ticket = new demo3();
        new Thread(ticket,"小黄").start();
        new Thread(ticket,"小名").start();
        new Thread(ticket,"小红").start();
    }
}

在这里插入图片描述
多个线程操作同一个资源的情况下，线程不安全，并发问题（在同一个CPU下，多个线程同时发起的任务请求，出现的问题就叫并发问题），数据紊乱。

二、深入了解Thread类

静态代理

在这里插入图片描述
这里首先you和weddingCompany是接口wedding的实现类，然后weddingCompany通过构造方法，需要传入一个you对象，从而代理可以帮you对象做一些事情，这就是静态代理；同理我们可以对比一下创造一个线程的时候，因为Thread是继承Runnable接口的，然后传入的参数类型也是Runnable接口类型，相当于是代理模式，Thread代理了Runnable接口实现了里面的方法，跟这里的weddingCompany代理you实现了里面的方法是一个道理。

三、Lamda表达式

简介

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

函数式接口

在这里插入图片描述

静态内部类

在这里插入图片描述

局部内部类

在这里插入图片描述

匿名内部类

在这里插入图片描述

lamda表达式

在这里插入图片描述
其实也就是把匿名内部类稍有改变，就是把new 实现类名给省略了，然后直接写函数式接口里面唯一的一个方法里面的内容就可以了，参数类型也可以省略

总结

在这里插入图片描述

四、线程的五大状态（生命周期）

在这里插入图片描述

线程的方法

在这里插入图片描述

线程停止的方法

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

线程礼让

在这里插入图片描述
记住：礼让不一定成功，看CPU心情

线程休眠

在这里插入图片描述
模拟网络延时：放大问题的发生性
在这里插入图片描述

Join

在这里插入图片描述
因为这里是并发执行的，所以main会先跑，然后我们这里用join方法让线程插队进来了

线程状态观测

在这里插入图片描述
死亡之后的线程不能再次启动了

线程的优先级

在这里插入图片描述

守护线程

在这里插入图片描述
守护线程可以理解为守护我们程序正常执行的线程，不用去管它们，我们可以通过setDaemon方法把用户线程升级为守护线程，虚拟机只用保证把用户线程执行完就可以了，守护线程不需要执行完

五、线程同步

介绍

发生在多个线程操作一个资源
在这里插入图片描述
并发就是多线程去抢占一个资源（包括CPU）
在这里插入图片描述
同步就是排队机制，线程一个个进入队列，资源每次都是一对一的跟线程进行操作，同步就是由队列+锁构成的
在这里插入图片描述

线程不安全例子

package com.yan.syn;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/17 10:42
 * @description：
 */
public class UnSafeBuyTicket {
    public static void main(String[] args){
        BuyTicket station = new BuyTicket();
        new Thread(station,"小红").start();
        new Thread(station,"小章").start();
        new Thread(station,"小蓝").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums=10;
    boolean flag=true;

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        if (ticketNums<=0){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

package com.yan.syn;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/17 11:04
 * @description：
 */
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        GetMoney you = new GetMoney(account,50,"你");
        GetMoney youWife = new GetMoney(account,100,"你妻子");
        you.start();
        youWife.start();
    }
}
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class GetMoney extends Thread{
    private Account account;
    private int drawingMoney;//取了多少钱
    private int nowMoney;

    public GetMoney(Account account, int drawingMoney,String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"卡里的钱不够了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money = account.money-drawingMoney;
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        System.out.println(Thread.currentThread().getName()+"手里还剩余的钱为"+nowMoney);
    }
}

public class UnSafeArrayList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 50000; i++) {
            new Thread(()-> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(list.size());
    }
}

可能在同一个index上后面进来的数据把前面的给覆盖掉了，所以线程是不安全的

解决办法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
锁的是方法的调用者（对象），休眠状态不会释放锁（继续保持锁住状态），这里是三个线程操作一个对象，调用方法锁的是对象车站，将这一个车站的数据都锁住了
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
这里两个线程进行操作，锁不住，多个线程只会锁住当前实例对象，这里是两个线程各自操作各自的对象，锁方法锁的是调用者，所以锁的是银行，而不是账户，所以我们需要将账户进行加锁，使用同步块
在这里插入图片描述
锁的对象就是变化的量，需要增删改的量
在这里插入图片描述
这里也是一个道理，把改变的变量锁住就可以了，这里改变的是list集合对象，锁住就完事儿了
ArrayList是线程不安全的，CopyOnWriteArrayList是线程安全的。

六、死锁

介绍

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

解决办法

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

小结

加上synchronized同步块的资源每次进来的对象都需要带着锁，当有两把锁的时候，锁住了当前的资源别人想要得到你的资源的时候，你却锁住了不放，就造成了死锁，这里的解决办法就是把我当前资源锁住之后，锁完就放，然后再去找你要你的东西就解决了，synchronized同步块运行结束之后就会释放锁，这里还没有释放锁就想着就找别人要资源，别人又要你的资源，东西就都锁住了，谁也不愿意释放，就死锁了，放在外面就相当于释放了我的东西了。

锁

介绍

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

对比

在这里插入图片描述

七、线程协作（生产消费者模式）

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

解决方式一

package com.yan.gaoji;

import com.sun.org.apache.bcel.internal.generic.PUSH;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/17 12:14
 * @description：
 */
public class TestPC {
    public static void main(String[] args) {
        hunCun hunCun = new hunCun();

        new Productor(hunCun).start();
        new Customer(hunCun).start();
    }
}
//生产者只顾生产，一直往缓存区里面加鸡
class Productor extends Thread{
    hunCun chun;

    public Productor (hunCun hunCun){
        this.chun=hunCun;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            try {
                chun.push(new Chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//消费者只顾消费，一直往缓存区里面取鸡
class Customer extends Thread{
    hunCun chun;

    public Customer (hunCun hunCun){
        this.chun=hunCun;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了"+chun.pop().no+"只鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Chicken {
    int no;

    public Chicken(int no) {
        this.no = no;
    }
}


class hunCun{
    Chicken[] chickens = new Chicken[10];
    int count =0;

    public synchronized void push(Chicken chicken) throws InterruptedException {
        if (count==chickens.length){
            //通知生产者等待
            this.wait();
        }
        chickens[count]=chicken;
        count++;
        //如果缓存区没有满，就唤醒生产者继续生产
        this.notify();
    }

    public synchronized Chicken pop() throws InterruptedException {
        if (count==0){
            //让消费者等待
            this.wait();
        }
        count--;
        //通知消费者可以消费了
        this.notify();
        return chickens[count];
    }
}

解决方式二

package com.yan.gaoji;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/17 12:41
 * @description：
 */
public class TestPC2 {
    public static void main(String[] args) {
        Chicken2 chicken2 = new Chicken2();
        new Product(chicken2).start();
        new Eat(chicken2).start();
    }
}
//生产者只顾生产，一直往缓存区里面加鸡
class Product extends Thread{
    Chicken2 chicken2;
    public  Product(Chicken2 chicken2){
        this.chicken2=chicken2;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                chicken2.zuo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//消费者只顾消费，一直往缓存区里面取鸡
class Eat extends Thread{
    Chicken2 chicken2;
    public  Eat(Chicken2 chicken2){
        this.chicken2=chicken2;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                chicken2.eat("一只小小鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Chicken2 {
    String eat;
    //如果为真，就吃，不能做，为假就做，不能吃
    boolean flag=true;

    public synchronized void eat(String eat) throws InterruptedException {
        //让消费者先不吃，生产者做
        if (!flag){
            this.wait();
        }
        System.out.println("吃了"+eat);
        //让消费者吃
        this.notifyAll();
        this.eat=eat;
        flag=!flag;
    }
    public synchronized void zuo() throws InterruptedException {
        //让生产者先不做，消费者吃
        if (flag){
            this.wait();
        }
        System.out.println("做了"+eat);
        //让生产者做，消费者吃
        this.notifyAll();
        flag=!flag;
    }
}

线程池

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

线程池创建的方法
public class TestMoreTread {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        service.shutdown();
    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
知道越多，知道越少
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Qt 线程池
weixin_46870692的博客
10-24 568
Qt 线程池
python线程start_Python线程类| start（）方法与示例
cumubi7552的博客
07-16 5034
python线程start Python Thread.start()方法 (Python Thread.start() Method) Thread.start() method is an inbuilt method of the Thread class of the threading module in Python. It is used to start a thread's ac...
线程池的使用步骤
weixin_49578980的博客
09-17 2742
线程池的使用步骤 使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池 创建一个类,实现Runnable接口,重写run方法,设置线程任务 调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法 调用ExecutorService中的方法shutdown销毁线程池(不建议执行) public class ThreadPool{ public static void main(Str
多线程讲解（详解）
最新发布
qq_71416673的博客
05-19 1112
说起多线程，那就不得不说什么是进程了，进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器因此一个进程当中就可能存在多个线程。多线程就是指一个进程中同时有多个执行路径（线程）正在执行。t1.start();t2.start();t3.start();创建一个类，实现Runnable这个接口重写run方法。
你的ThreadLocal线程安全么
weixin_30784945的博客
05-24 481
想必很多小伙伴们对ThreadLocal并不陌生，ThreadLocal叫做线程本地变量，也就是ThreadLocal为变量在每个线程中都创建了一个副本，每个线程可以访问自己内部的副本变量。那么，我们使用ThreadLocal一定线程安全么？话不多说，先上结论： 如果threadlocal.get之后的副本，只在当前线程中使用，那么是线程安全的；如果对其他线程暴露，不一定是线程安全...
python thread start_Python多线程-thread.start_new_thread简单使用
weixin_39571749的博客
12-21 1363
在使用python多线程的时候，踩到了主线程未等待多线程进程运行完成就结束，导致多线程无效的坑。后来想到自己写个全局变量监控多线程是否全部完成。话不多说，上代码。def test(i):global unfinished_threadprint '开始运行第%s个进程'%itime.sleep(i)lock.acquire()unfinished_thread -= 1print '结束运行第%s...
狂神说多线程详解.rar
05-06
综上所述，《狂神说多线程详解》涵盖了多线程编程的基础理论、实践技巧以及常见的问题和解决方案，对于开发者来说是一份宝贵的参考资料。通过学习，开发者可以深入理解多线程的工作原理，并在实际项目中有效应用。
C#多线程与异步的区别详解
12-31
C#多线程与异步的区别详解 随着拥有多个硬线程 CPU（超线程、双核）的普及，多线程和异步操作等并发程序设计方法也受到了更多的关注和讨论。本文主要是想与各位高手一同探讨一下如何使用并发来最大化程序的性能。 ...
python程序 创建多线程过程详解
09-18
在Python中，多线程是一种并发执行任务的技术，允许程序同时处理多个任务，从而提高效率。本文将深入探讨如何在Python程序中创建多线程，以及线程模块的选择和使用。 首先，Python提供两个主要的线程模块：`thread`...
Python 多线程的实例详解
09-21
### Python多线程的实例详解 #### 一、线程基础 在计算机科学中，线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。Python 提供了两种标准的方式来实现多线程：`thread` ...
C#多线程基础
11-16
### C#多线程基础详解 #### 知识点一：多线程概念与优势 在C#中，多线程是指一个程序中同时执行多个线程的能力。一个线程是程序执行的基本单位，每个线程都有自己的指令指针、栈和局部变量，但共享相同的内存空间...
【原创】读写锁ReentrantReadWriteLock原理分析(一)
weixin_33750452的博客
02-25 97
Java里面真正意义的锁并不多，其实真正的实现Lock接口的类就三个，ReentrantLock和ReentrantReadWriteLock的两个内部类（ReentrantReadWriteLock实现了ReadWriteLock接口，并没有实现Lock接口，是其内部类ReadLock和WriteLock实现了Lock的接口），其他都是通过我们前面说的一些工具类实现了线程的阻塞。 ...
Python—MySQL线程池
weixin_30454481的博客
01-11 840
python实现版本：#!/usr/python/bin/python3 # -*- coding:utf-8 -*- ############################ #File Name: mysql_threading_pool.py #Author: ykyk #Mail: 525178992@qq.com #Created Time: 2019-01-10 09:17:32 ##...
python thread start_python线程之start_new_thread - ksnowlv
weixin_39834205的博客
12-21 755
Python中使用线程有两种方式：1.函数式方式2.类包装线程对象方式。下面使用函数式方式，调用thread模块中的start_new_thread()函数来产生新线程。语法格式如下:thread.start_new_thread ( function, args[, kwargs] )代码示例如下:#!/usr/bin/pythonimport threadimport time#为线程定义一个...
python多线程中锁的概念
weixin_34242509的博客
03-29 442
python的锁可以独立提取出来 mutex = threading.Lock() #锁的使用 #创建锁 mutex = threading.Lock() #锁定 mutex.acquire([timeout]) #释放 mutex.release() 概念 好几个人问我给资源加锁是怎么回事，其实并不是给资源加锁, 而是用锁去锁定资源，你可以定义多个锁, 像下...
Python threading中lock的使用
热门推荐
锅炉房刘大爷的博客
03-28 3万+
在多线程中使用lock可以让多个线程在共享资源的时候不会“乱”，例如，创建多个线程，每个线程都往空列表l中添加一个数字并打印当前的列表l，如果不加锁，就可能会这样：# encoding=utf8 import threading import time lock = threading.Lock() l = [] def test1(n): lock.acquire() l.append...
ReentrantReadWriteLock原理
crazy_lala的博客
12-05 406
读写锁：ReentrantReadWriteLock 当读操作远远高于写操作时，这时候使用 读写锁 让 读-读 可以并发，提高性能。类似于数据库中select … from … lock in share mode。 使用举例： package com.concurrent.test; import java.util.concurrent.locks.ReentrantReadWriteLock; public class TestReadWriteLock { public static
QT-线程池
最爱吹吹风
04-19 8494
在程序逻辑中经常会碰到需要处理大批量任务的情况，比如密集的网络请求，或者日志分析等等。一般会创建一个队列，用一个或者多个线程去消费这个队列，一般也要处理队列的加锁和解锁的问题，除非在设计时就能够做到专列专用，否则锁是不可避免的。而且在入队和出队的操作上肯定还是要加锁，因为他们是在不同线程对同一个资源进行操作。 线程池就是为这个而设计的，比如 Wi...
Qt线程池
weixin_45001971的博客
02-17 5790
Qt线程池
JAVA多线程基础详解：从概念到死锁
"JAVA多线程基础" 在Java编程中，多线程是核心概念之一，它使得程序能够同时处理多个任务，从而提高了系统的效率和响应性。本文将深入讲解Java多线程的基础知识，帮助读者建立坚实的理论基础，为进一步的学习铺平...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值