多线程

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

多线程

一、线程对象的创建

账户里面一共有1000块钱，男人和女人同时取没人一次取走五块，取20次。

实现Runnable接口

package com.ouc.a302.synchronizeddemo;

public class Account implements Runnable{
    private static int money=1000;
    private int amount;

    public Account(int amount) {
        this.amount = amount;
    }

    public static int getMoney() {
        return money;
    }

    public static void setMoney(int money) {
        Account.money = money;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    @Override
    public void run() {
        try {
            withDraw(amount);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public  void withDraw(int amount) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            money=money-amount;
            System.out.println(Thread.currentThread().getName()+"--->"+"The account balance is" +"$"+money);
            Thread.sleep(1000);
        }
        System.out.println("amount = " + amount);
    }

    public static void main(String[] args) {
        Account account=new Account(5);
        Thread thread1=new Thread(account,"male");
        Thread thread2=new Thread(account,"female");
        thread1.start();
        thread2.start();
    }
}

Thread.currentThread().getName() 这一句可查看线程的名称

二、同步锁

1、同步方法

如果直接采用上面这种方法，运行的时候会存在线程安全问题，男人取完5块钱之后，余额本来应该剩下995元，女人再取5元之后，余额应该剩余990元，但是经过实验发现，有时候，男人取完，女人再取，并不会减去男人取走的钱，这就是线程安全问题。
在这里插入图片描述
解决方式，就是再取钱的方法上加同步字段—让方法变成同步方法。

package com.ouc.a302.synchronizeddemo;

public class Account extends Thread{
    private static int money=1000;
    private int amount;

    public Account(int amount) {
        this.amount = amount;
    }

    public static int getMoney() {
        return money;
    }

    public static void setMoney(int money) {
        Account.money = money;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    @Override
    public void run() {
        try {
            withDraw(amount);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void withDraw(int amount) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            money=money-amount;
            System.out.println(Thread.currentThread().getName()+"--->"+"The account balance is" +"$"+money);
            Thread.sleep(1000);
        }
        System.out.println("amount = " + amount);
    }

    public static void main(String[] args) {
        Account account=new Account(5);
        Thread thread1=new Thread(account,"male");
        Thread thread2=new Thread(account,"female");
        thread1.start();
        thread2.start();
    }
}

同步方法：

public synchronized void withDraw(int amount) throws InterruptedException {
    for (int i = 0; i < 20; i++) {
        money=money-amount;
        System.out.println(Thread.currentThread().getName()+"--->"+"The account balance is" +"$"+money);
        Thread.sleep(1000);
    }
    System.out.println("amount = " + amount);
}

在这里插入图片描述
男人取钱的线程执行的时候，女人的线程不能执行，sychronized字段就是把同步方法所在的对象给锁死，第一个线程操作该对象的时候，把门锁死，其他线程只能等第一个线程执行完了之后才能操作对象。
即，同步方法锁掉的对象是this。

2、同步代码块

package com.ouc.a302.synchronizeddemo;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
    int money=1000;
    public Account() {
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
class Amount implements Runnable{
    int moneyInHand=0;
    Account account;
    private final ReentrantLock reentrantLock=new ReentrantLock();
    public Amount(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        synchronized (account){
            while(true){
                if (account.money<=0){
                    break;
                }
                test();
            }
        }
    }
    private void test(){
        if (account.money<=0){
            System.out.println(Thread.currentThread().getName()+"余额不足");
        }else {
            moneyInHand=moneyInHand+5;
            System.out.println(Thread.currentThread().getName()+"手上有"+moneyInHand);
            account.money=account.money-5;
        }
    }
    public static void main(String[] args) {
        Account account=new Account();
        Amount amountman=new Amount(account);
        Amount amountwoman=new Amount(account);
        Thread t1=new Thread(amountman,"man");
        Thread t2=new Thread(amountwoman,"woman");
        t1.start();
        t2.start();
    }
}

当需要锁住的对象不是同步方法所在的对象时，则可以通过上面的方法采用同步代码块，来锁住相应的对象。

同步方法相当于里面有synchronized(this) 这个同步代码块只不过隐藏了。

3、lock锁

package com.ouc.a302.synchronizeddemo;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
    int money = 1000;
    public final ReentrantLock reentrantLock = new ReentrantLock();
    public Account() {
    }

    public int getMoney() {
        return money;
    }


    public void setMoney(int money) {
        this.money = money;
    }
}


class Amount implements Runnable {
    int moneyInHand = 0;
    Account account;


    public Amount(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.reentrantLock.lock();
        while (true) {
            if (account.money <= 0) {
                break;
            }
            test();
        }
       account.reentrantLock.unlock();
    }

    private void test() {
        if (account.money <= 0) {
            System.out.println(Thread.currentThread().getName() + "余额不足");
        } else {
            moneyInHand = moneyInHand + 5;
            System.out.println(Thread.currentThread().getName() + "手上有" + moneyInHand);
            account.money = account.money - 5;
        }
    }

    public static void main(String[] args) {
        Account account = new Account();
        Amount amountman = new Amount(account);
        Amount amountwoman = new Amount(account);
        Thread t1 = new Thread(amountman, "man");
        Thread t2 = new Thread(amountwoman, "woman");
        t1.start();
        t2.start();
    }
}

需要锁哪个对象，就把ReentrantLock类定义在哪个类里面。

三、线程通信

1、管程法

package com.ouc.a302.synchronizeddemo;

public class PCTest {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        new Product(buffer).start();
        new Consumer(buffer).start();
    }
}

//生产者
class Product extends Thread {
    Buffer buffer;

    public Product(Buffer buffer) {
        this.buffer = buffer;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            buffer.push(new Anything(i));
            System.out.println("生产了" + i + "个产品");
        }
    }
}

//消费者
class Consumer extends Thread {
    Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第" + buffer.get() + "个产品");
        }
    }
}

//缓冲区
class Buffer {
    Anything[] anythings = new Anything[10];
    int count = 0;

    //生产者放入产品
    public synchronized void push(Anything anything) {
        //容器满了
        if (count == anythings.length) {
            try {
                //通知消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        anythings[count] = anything;
        count++;
        //通知消费者消费
        notifyAll();
    }

    public synchronized int get() {
        //容器空了
        if (count == 0) {
            try {
                //通知生产者生产
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Anything anything = anythings[count];
        //通知生产者生产
        notifyAll();
        return anything.id;
    }
}

class Anything {
    int id;

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

把生产者生产的产品放入缓存区，通知消费者从缓存区把产品拿出来，然后再通知生产者生产。

2、信号灯法

package com.ouc.a302.synchronizeddemo;

public class PCTest {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//演员
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("新闻联播播放中");
            } else {
                this.tv.play("天气预报播放中");
            }
        }
    }
}

//观众
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品
class TV {
    //演员表演，观众等待

    //观众观看，演员等待

    String voice;//表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了" + voice);
        //通知观众观看
        this.notifyAll();//唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

四、线程池

package com.ouc.a302.synchronizeddemo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //1.创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        //2.关闭连接
        executorService.shutdown();
    }
}

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}
m0_46473771
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java多线程实战-CountDownLatch模拟压测实现
热门推荐
qq_35716689的博客
03-17 22万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程
一个小小的码农
07-17 4462
多线程进程其他相关概念创建线程的两种方式为什么使用start（）方法而不直接使用run（）方法start（）方法底层继承Thread 和 实现Rnnable的区别售票系统SellTicket01类继承Thread实现SellTicket02类实现Runnable接口线程终止基本说明通知方式线程常用方法常用第一组注意事项和细节常用方法第二组案例常用方法第三组用户线程和守护线程线程的生命周期线程同步机制利用同步解决买票超卖问题互斥锁基本介绍注意事项和细节线程死锁释放锁练习题同步方法同步代码块 进程 1、进程是指
多线程 join 方法
Gonelin的博客
12-22 6274
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
多线程入门
南风的博客
03-29 7617
多线程 感谢狂神说 java --秦疆老师的教学，教学视频地址 创建线程方式一 //创建线程方式一： 继承Thread类，重写run()方法，调用start开启线程 public class ThreadDemo extends Thread { @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看" + i);
Delphi多线程总结
疯流人物
10-23 2726
多线程总体认识 当前程序是一个进程, 进程只是一个工作环境, 线程是工作者; 每个进程都会有一个启动线程(或叫主线程), 也就是说: 大量的编码都是写给这个主线程的; ExitThread(0); 退出主线程; 系统不允许一个没有线程的进程存在, 所以程序就退出了. ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可. ...
Qt多线程
qq292263211的博客
06-02 4110
Qt多线程有两种方法： 1、定义一个QThread的派生类，重写run函数，run函数中的程序就是新线程中要执行的内容。在主线程中实例化该类，调用start函数，就可以实现多线程。 2、定义一个QObject的派生类，把要在新线程中执行的内容写在一个槽函数中，然后把该派生类的对象传给QThread对象的moveToThread函数，用一个信号和槽函数绑定，当信号触发时，槽函数中的内容就会在子线程执行。 第一种方法 首先定义一个QThread的派生类 #ifndef MTHREAD_H #define M
多线程简介
Bug_marker的博客
11-29 4715
一、概念 1、并发与并行 并行：多个任务在同一个时刻点同时执行。效率高 并发：多个任务在同一段时间内分时执行。效率低，宏观上同时执行，微观上分时执行。 2、进程与线程 进程：内存中正在运行的应用程序，是系统进行资源分配和调度的基本单位。每一个进程有自己独立的运行空间，相互之间不影响。进程就是程序的一次执行过程，即是一个进程从加载到内存到从内存中释放消亡的过程。 线程：进程内部的独立运行单元，是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序.
Python 多线程学习
Herishwater的博客
05-10 3517
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
linux多线程
weixin_46485873的博客
07-09 3074
多线程：所有程序并发运行，多条路径可以同时执行 多线程包括：理解线程并发、线程同步方法、线程安全概念 线程指：进程内部得一条执行路径（从主函数的第一行代码到最后一行）主线程：main 子线程：线程函数 比如：fun.... 进程指：一个正在运行的程序 在linux平台创建线程，是内核提供的头文件#include注意编译的时候要加 -lpthreadpthread_create(线程id，默认的属性可以不设置为NULLL，参数函数); 创建线程子线程如下图 有些时候主线......
多线程实现事务回滚
吃素的哈士奇de博客
06-10 1万+
多线程实现事务回滚特别说明CountDownLatchCountDownLatch的用法CountDownLatch(num) 简单说明主线程：mainThreadLatch.await() 和mainThreadLatch.countDown()子线程：rollBackLatch.await() 和rollBackLatch.countDown()**为什么所有的子线程会在一瞬间就被所有都释放了？**事务的回滚是怎么结合进去的？假设总共20个子线程，那么其中一个线程报错了怎么实现所有线程回滚。引入变量At
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
弹性力学数值方法：积分法：积分法基本原理.docx
09-01
弹性力学数值方法：积分法：积分法基本原理.docx
autots-0.5.7-py3-none-any.whl.zip
09-01
autots-0.5.7-py3-none-any.whl.zip
AutoTS-0.5.0-py3-none-any.whl.zip
09-01
AutoTS-0.5.0-py3-none-any.whl.zip
基于springboot的医药管理系统设计与实现.docx
最新发布
09-01
基于springboot的医药管理系统设计与实现.docx
Aspeed AST2400 BMC datasheet V14
09-01
Aspeed AST2400 BMC datasheet V14
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值