多线程学习

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量406 收藏
点赞数
文章标签： java c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46543456/article/details/127692207
版权

多线程的实现方式

  1. 继承Thread方法
  2. 实现Runable接口
  3. 实现Callable接口

1.继承Thread方法 

创建一个类继承Thread类，重写run方法

通过多态创建一个子线程，子线程调用start方法

//创建线程方式一：继承Thread类，重现run方法
public class TestThread1 extends Thread{
    @Override
    public void run(){
        for (int i=0;i<20;i++){
            System.out.println(currentThread().getName()+"执行"+i);
        }
    }

    public static void main(String[] args) {
        //创建一个子线程
        Thread thread = new TestThread1();
        //线程启动
        thread.start();


        for (int i=0;i<200;i++){
            System.out.println(currentThread().getName()+"执行"+i);
        }
    }
}

2.实现Runnable接口

创建一个类实现Runnable接口

重写run方法

创建runnable接口实现类对象

创建Thread类对象，通过线程对象来开启我们的线程

// 创建线程的方式2：实现runanable接口，重新写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i=0 ; i<100; i++){
            System.out.println(currentThread().getName()+":"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread3,"子线程1");
        thread.start();
        currentThread().setName("主线程");
        for (int i = 0; i < 100; i++) {
            System.out.println(currentThread().getName()+":"+i);
        }
    }
}

小结

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

 并发线程遇到数据紊乱问题

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

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{

    //票数
    private int sum = 20;

    @Override
    public void run() {
        while (true){
            if (sum<=0){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+sum--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();
        new Thread(testThread4,"线程1").start();
        new Thread(testThread4,"线程2").start();

    }
}


线程1拿到了第19票
线程2拿到了第20票
线程1拿到了第17票
线程2拿到了第18票
线程1拿到了第16票
线程2拿到了第15票
线程2拿到了第14票
线程1拿到了第13票
线程1拿到了第12票
线程2拿到了第11票
线程1拿到了第9票
线程2拿到了第10票
线程1拿到了第8票
线程2拿到了第8票
线程2拿到了第7票
线程1拿到了第6票
线程2拿到了第4票
线程1拿到了第5票
线程1拿到了第3票
线程2拿到了第2票
线程1拿到了第1票
线程2拿到了第0票

3.实现CallAble接口 

  1. 创建执行服务：创建线程池
  2. 提交执行
  3. 获取结果
  4. 关闭服务

重写call方法，创建线程池，提交线程子类

/**
 * 可以拥有返回值
 * 可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        String inputurl = "mvnw.cmd";
        String outputurl = Thread.currentThread().getName()+".cmd";
        InputStream inputStream = new FileInputStream(inputurl);
        OutputStream outputStream = new FileOutputStream(outputurl);
        byte[] bytes = new byte[1024];
        while (inputStream.read(bytes)!=-1){
            outputStream.write(bytes);
        }
        return Boolean.TRUE;
    }

    public static void main(String[] args) throws Exception {
        TestCallable t1 =new TestCallable();
        TestCallable t2 =new TestCallable();
        TestCallable t3 =new TestCallable();

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

        //提交执行
        Future<Boolean> submit1 = ser.submit(t1);
        Future<Boolean> submit2 = ser.submit(t2);
        Future<Boolean> submit3 = ser.submit(t3);

        //获取结果
        Boolean aBoolean1 = submit1.get();
        Boolean aBoolean2 = submit2.get();
        Boolean aBoolean3 = submit3.get();

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

线程的状态

  • 创建状态
  • 就绪状态
  • 运行状态
  • 阻塞状态
  • 死亡状态

方法说明
setPriority(int newPriority)更改线程优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrrupt()中断线程（不用）
boolean isAlive测试线程是否处于活动状态

线程休眠

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

线程礼让

yield不一定成功

/**
 * 测试yield
 * 礼让不一定成功
 */
public class TestYield{
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        Thread t1 = new Thread(myYield,"a线程");
        Thread t2 = new Thread(myYield,"b线程");
        t1.start();
        t2.start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }
}

线程优先级

  • Java提供一个线程调度器来监控程序中启动进入就绪状态的所有线程，线程调度器按照优先级决定的那个应该调度哪个线程来执行
  • 线程的优先级用数字表示，范围从1~10
    • Thread.MIN_PRIORITY=1;
    • Thread.Max_PRIORITY=10;
    • Thread.NORM_PRIORITY=5;
  • 使用一下方式改变或获取优先级
    • getPriority.setPRiority(int xxx);
public class TestPriority {

    public static void main(String[] args) {
        Mypriority mypriority = new Mypriority();
        Thread t1 = new Thread(mypriority, "t1");
        Thread t2 = new Thread(mypriority, "t2");
        Thread t3 = new Thread(mypriority, "t3");
        t2.setPriority(4);
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
        System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
    }
}


class Mypriority implements Runnable{

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

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必去确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕，守护线程等待最后一个用户线程结束结束
  • 守护线程:操作日志，监控内存，垃圾回收等待。
//测试守护线程

public class TestDaemon {
    public static void main(String[] args) {
        Thread human = new Thread(new Human());
        Thread god = new Thread(new God());
        Thread human2 = new Thread(new Human2());
        god.setDaemon(true);//开启守护线程
        human.start();
        god.start();
        human2.start();
    }
}

class Human implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("用户进程"+i);
        }
    }
}

class God implements Runnable{

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("守护进程");
        }
    }
}

class Human2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("用户线程2"+i);
        }
    }
}

线程的同步机制

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被i访问时的正确性，在访问时加入锁机制sychronized，当一个线程获得对象的排他锁，独占资源，其他线程必须的等待，

使用后释放锁即可，存在下列问题：

  • 一个线程持有锁会导致其他所有拥有此锁的线程挂起：
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

同步方法 

  • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized放啊和synchronized块
  • 同步方法：public synchronized void method(int args){}
  • synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
  • 缺陷：若将一个大的方法申明为synchronized将会影响效率

同步块 

  • 同步块：synchronized（OBJ）{}
  • Obj称之为同步监视器
    • Obj可以是任何对象，到那时推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射】
  • 同步监视器的执行过程
    • 第一个线程访问，锁定同步监视器

死锁

死锁：多个线程互相抱着对方需要的资源，然后形成僵持

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

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

public class DeadLock extends Thread{

    public static void main(String[] args) {
        Thread t1 = new DeadLock(0);
        Thread t2 = new DeadLock(2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    private int choose = 0;
    private String lipstick ="a";
    private String mirror ="b";
    @Override
    public void run() {
        if (choose == 0){
            synchronized (lipstick){
                System.out.println(Thread.currentThread().getName()+"lipstick");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (mirror){
                    System.out.println(Thread.currentThread().getName()+"mirror");
                }
            }
        }else {
            synchronized (mirror){
                System.out.println(Thread.currentThread().getName()+"lipstick");
                synchronized (lipstick){
                    System.out.println(Thread.currentThread().getName()+"mirror");
                }
            }
        }

    }

    public DeadLock(int choose){
        this.choose = choose;
    }
}

Lock（锁） 

package cn.cslg.kuangshen.lock;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        Thread t1 = new Thread(testLock2,"t1");
        Thread t2 = new Thread(testLock2,"t2");
        t1.start();
        t2.start();
    }
}

class TestLock2 implements Runnable{
    private int ticketNums =10;
    //定义lock锁
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            //加锁
            lock.lock();
            while (ticketNums>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+ticketNums--);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            //解锁
            lock.unlock();
        }

    }
}

生产者消费者问题 略过

使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

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

    public static void main(String[] args) {
        //创建服务，创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        //执行
        executorService.submit(new TestThread());
        executorService.submit(new TestThread());
        executorService.submit(new TestThread());
        //关闭连接
        executorService.shutdown();
    }
}

class TestThread implements Runnable{

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

kzz不想学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
labview多线程学习
09-03
labview多线程学习
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
多线程学习资源
02-05
多线程概述，past，coolie，多线程控制，多线程验证码
java多线程学习
11-27
主要是结合课本和视频学习了一下java多线程的用法，这个专利适合于初学者学习多线程知识。
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 947
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 976
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 771
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 277
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 249
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 508
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
java多线程创建方式
weixin_57763462的博客
05-28 1071
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1025
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1061
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 163
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
继承与无参构造器
2301_79842503的博客
05-30 226
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
Java进阶学习笔记27——StringBuilder、StringBuffer
CCH2024的专栏
05-26 288
Java进阶学习笔记
Servlet搭建博客系统
Smarmot的博客
05-31 628
现在我们可以使用Servlet来搭建一个动态(前后端可以交互)的博客系统.(使用Hexo只能实现一个纯静态的网页,即只能在后台自己上传博客)
Java实现AES，DES，RSA加密
编写博客，学习交流
05-29 412
这个标准用来替代原先的DES,AES加密过程涉及到4种操作，分别是字节替代、行移位、列混淆和轮密钥加。解密过程分别为对应的逆操作。由于每一步操作都是可逆的，按照相反的顺序进行解密即可恢复明文。加解密中每轮的密钥分别由初始密钥扩展得到。算法中16个字节的明文、密文和轮密钥都以一个4x4的矩阵表示。
java多线程学习计划
12-21
以下是一个Java多线程学习计划的简要介绍： 1. 学习多线程的基本概念：了解程序、进程和线程的概念，以及多线程的优点和何时需要使用多线程。 2. 学习线程的创建和使用：掌握使用Thread类创建和启动线程的方法，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值