java基础之多线程（2）

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量132 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JULIAN__/article/details/106985007
版权

一.多线程的安全问题

1.线程同步（加锁）这里针对上一节的卖票程序做改进，就是线程的同步

		多线程并发访问的时候回出现数据安全问题：
 *          解决方式：
 *              1、同步代码块
 *                  synchronized(共享资源、共享对象，需要是object的子类){具体执行的代码块}
 *              2、同步方法
 *                  将核心的代码逻辑定义成一个方法，使用synchronized关键字进行修饰，此时不需要指定共享对象

同步代码块：

*
 * 使用接口的方式，每次只创建了一个共享对象，所有的线程能够实现资源共享
 *      1、数据不一致的问题
 *          解决方法：线程同步（同步代码块）
 *
 */
public class TicketRunnable2 implements Runnable {

    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this){
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
                }
            }
        }
    }

    public static void main(String[] args) {
        TicketRunnable2 ticket = new TicketRunnable2();
        Thread t1 = new Thread(ticket,"A");
        Thread t2 = new Thread(ticket,"B");
        Thread t3 = new Thread(ticket,"C");
        Thread t4 = new Thread(ticket,"D");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

同步方法：


**
 * 使用接口的方式，每次只创建了一个共享对象，所有的线程能够实现资源共享
 * 1、数据不一致的问题
 * 解决方法：线程同步
 */
public class TicketRunnable3 implements Runnable {

    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.sale();
        }
    }

    /*
     * 使用同步方法解决多线程数据安全的问题
     * */
    public synchronized void sale() {

        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "正在出售第" + (ticket--) + "张票");
        }
    }

    public static void main(String[] args) {
        TicketRunnable3 ticket = new TicketRunnable3();
        Thread t1 = new Thread(ticket, "A");
        Thread t2 = new Thread(ticket, "B");
        Thread t3 = new Thread(ticket, "C");
        Thread t4 = new Thread(ticket, "D");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

2.线程同步小结：

▪ 同步监视器
   – synchronized(obj){}中的obj称为同步监视器
   – 同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监 视器
   – 同步方法中无需指定同步监视器，因为同步方法的监视器是this，也就是该对象 本身
   
▪ 同步监视器的执行过程 
– 第一个线程访问，锁定同步监视器，执行其中代码 
– 第二个线程访问，发现同步监视器被锁定，无法访问 
– 第一个线程访问完毕，解锁同步监视器 
– 第二个线程访问，发现同步监视器未锁，锁定并访问

二。生产者和消费者

生产者：

package com.mashibing.Thread.pc3;

public class Producer implements Runnable {

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            if (i%2==0){
               goods.set("娃哈哈","矿泉水");
            }else {
                goods.set("旺仔","小馒头");
            }
        }
    }
}

消费者：

package com.mashibing.Thread.pc3;

public class Comsumer implements Runnable {

    private Goods goods;

    public Comsumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            goods.get();
        }
    }
}

共享对象：

package com.mashibing.Thread.pc3;

public class Goods {
    private String brand;
    private String name;

    //默认是不存在商品的，如果值等于true的话，代表有商品
    private boolean flag = false;



    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //生产者生产商品
    public synchronized void set(String brand,String name){
        //当生产者抢占到cpu资源之后会判断当前对象是否有值，如果有的话，以为着消费者还没有消费，需要提醒消费者消费，同时
        //当前线程进入阻塞状态，等待消费者取走商品之后，再次生产，如果没有的话，不需要等待，不需要进入阻塞状态，直接生产即可
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.setBrand(brand);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setName(name);
        System.out.println("生产者生产了"+this.getBrand()+"--"+this.getName());
        //如果代码执行到此处，意味着已经生产完成，需要将flag设置为true
        flag = true;
        //唤醒消费者去进行消费
        notify();
    }



    //消费者获取商品
    public synchronized void get(){
        /*
         * 如果flag等于false的话，意味着生产者没有生产商品，此时消费者无法消费，需要让消费者线程进入到阻塞状态，等待生产者生产，当
         * 有商品之后，再开始消费
         * */
        if (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者取走了"+this.getBrand()+"--"+this.getName());
        flag = false;
        //唤醒生产者去进行生产
        notify();

    }
}

测试类：

package com.mashibing.Thread.pc3;

public class Test {
    public static void main(String[] args) {
        Goods goods = new Goods();
        Producer producer = new Producer(goods);
        Comsumer comsumer = new Comsumer(goods);

        Thread thread = new Thread(producer);
        Thread thread1 = new Thread(comsumer);

        thread.start();
        thread1.start();
    }
}

具体的版本更替从pc1-pc4详细讲本机代码；

三。用juc实现的生产者和消费者案例

生产者：

package com.mashibing.Thread.pc4;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

public class ProducerQueue implements Runnable {

    private BlockingQueue<Goods> blockingQueue;

    public ProducerQueue(BlockingDeque<Goods> blockingDeque) {
        this.blockingQueue = blockingDeque;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            Goods goods = null;
            if (i%2==0){
                goods = new Goods("哇哈哈","矿泉水");
            }else {
                goods = new Goods("旺仔","小馒头");
            }
            System.out.println("生产者开始生产商品："+goods.getBrand()+"--"+goods.getName());
            try {
                blockingQueue.put(goods);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者：

package com.mashibing.Thread.pc4;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

public class ConsumerQueue implements Runnable {

    private BlockingQueue<Goods> blockingQueue;

    public ConsumerQueue(BlockingDeque blockingDeque) {
        this.blockingQueue = blockingDeque;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Goods goods = blockingQueue.take();
                System.out.println("消费者消费的商品是："+goods.getBrand()+"--"+goods.getName());
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

共享对象：

package com.mashibing.Thread.pc4;


public class Goods {

    private String brand;
    private String name;

    public Goods(String brand, String name) {
        this.brand = brand;
        this.name = name;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

测试类：

package com.mashibing.Thread.pc4;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Test {

    public static void main(String[] args) {
        BlockingQueue<Goods> queue1 = new ArrayBlockingQueue<Goods>(5);
        ProducerQueue producerQueue = new ProducerQueue(queue1);
        ConsumerQueue consumerQueue = new ConsumerQueue(queue1);
        new Thread(producerQueue).start();
        new Thread(consumerQueue).start();
}
是阿楷啊
关注
专栏目录
java多线程基础（二）
张毅的博客
06-03 189
java多线程基础（二）1.ThreadLocal1.2 ThreadLocal原理1.3 ThreadLocal 内存泄露问题 1.ThreadLocal ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 ThreadLocal 是 JDK java.lang 包中的一个用来实现相同线程数据共享不同的线程数据隔离的一个工具。 如果你创建了
Java多线程（二）
qq_34668134的博客
04-28 173
synchronized关键字 解决的问题： 保证同一时刻，只有一个线程访问某个方法或代码片段，即保证线程安全的。 作用范围： 【synchronized修饰实例方法】验证： package hccool._synchronized3; /** * @author hgh * @Package hccool._synchronized3 * @createDate 2020...
Java中启动线程start和run的两种方法
08-28
start()方法它的作用是启动一个新线程，run()就和普通的成员方法一样，可以被重复调用。接下来通过本文给大家分享Java中启动线程start和run的两种方法，需要的朋友参考下吧
双线程操作
bmbm546的专栏
07-20 1945
建立一个对话框，添加一个进度条控件和两个按钮控件。将两个按钮名字分别改为“启动线程1”，“启动线程2”，ID分别改为IDC_THREAD1和IDC_THREAD2。然后为对话框插入一个MENU资源并编辑，ID为IDR_MENU1.并在对话框属性中的菜单（M）项中将IDR_MENU1选中，即将菜单添加到对黄框中。再插入一个位图资源并编辑，ID号为IDI_HEART，用于线程1，平行移动。在头文件中定义四个protected变量 BOOL m_bSuspend1;  //判断线程1是否启动 BOOL m_bSu
优先级反转 - C语言模拟实现及解决方案
动感超人_Crush
09-19 787
什么是优先级反转 先举一个共享资源竞争的例子：两个线程需要同时将同一个变量 V（初始值为 0）进行自增操作。解决共享资源竞争的办法是加入一把锁，在访问变量 V 前占有该锁，在访问后释放该锁。一般情况下，我们可以使用初始值为 TRUE 的二进制信号量或初始值为 1 的计数型信号量作为锁。 现在我们把这个例子稍加改动，有三个线程（线程 A、线程 B、线程 C）和一个变量 V，线程 A 和线程 B 需要同时访问变量V。很显然我们需要一把锁（即保护变量 V 的锁 L）。 线程 A 的优先级为 ...
线程启动的方法start()和run()
Peanut的博客
03-23 3945
1.start 使用start方法才真正实现了多线程运行，因为使用start（）方法不用等待run方法体代码执行完毕而直接继续执行下面的代码。 因为thread线程有5种状态，创建-就绪-运行-阻塞-死亡这五种，用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，等到cpu空闲时，才会执行线程里面的run方法，run方法运行完毕，此线程结束。 2.ru...
多线程卖票问题
小泽
03-28 139
public class Ticket { private int number =30; public void sale(){ if(number > 0){ System.out.println(Thread.currentThread().getName() + "卖出了" +(number--) + "票，剩余：" + number); } } public static void mai...
Java基础之多线程
08-26
以下是对Java多线程基础知识点的详细解释： 1. **线程启动与执行**： - `start()` 方法用于启动线程，将线程放入操作系统的线程队列等待CPU调度执行，调用后会自动执行`run()` 方法。 - `run()` 方法是线程的主要...
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
线程启动详解
bc_Reversing的博客
04-23 670
一、start()和run() 这两个方法是在开发中实现多线时，最常接触的方法，start()是线程启动的方法，run()是线程中具体要实现的业务逻辑，这两个方法有直接的联系，但又是两个完全不同的方法，start()用来启动一个新的线程，而启动的新的线程主题逻辑就是run()。这两个方法不能孤立存在，只有start()不产生任何现实意义，只有run()不会创建新的线程。 实例代码： public class StartAndRunMethod { public static void mai
二.开启多线程启动
as513385的博客
04-08 178
二.开启多线程启动的世界 1.启动线程的正确和错误方式 public static void main(String[] args) { Runnable run = () -> System.out.println(Thread.currentThread().getName()); run.run(); sout(); Thread thread = new Thread(run); thread.start(
两个按钮分别是线程的打开和终止
weixin_34249367的博客
08-14 130
public partial class Form1 : Form    {        Thread thread=null;        int n = 0;bool severIsRun=false;//用来村示线程是否启动private delegate void myDelegate(string str);//定义委托private void setRich(string str)...
java 线程启动线程_Java多线程之线程的启动
weixin_32159409的博客
02-12 303
Java多线程之线程的启动一、前言启动线程的方法有如下两种。利用Thread 类的子类的实例启动线程利用Runnable 接口的实现类的实例启动线程最后再介绍下java.util.concurrent.ThreadFactory中的线程创建下面分别做以介绍二、利用Thread 类的子类启动线程这里来学习一下利用Thread 类的子类的实例来启动线程的方法，即上一篇博文中使用的方法。我们构造一个Pr...
Java基础-Runnable启动线程的使用
二丫的博客
09-26 3750
Runnable启动线程的使用 实现线程的第二种方式： Runnable接口 Runnable 接口的实现类的线程 通过Thread类启动 需要把实现类对象传入Thread类的构造方法中 然后通过Thread的start方法启动该Runnable实现类的线程。 Runnable实现类线程 只需要创建一个对象 然后传入多个Thread类构造方法中，通过多个Thread对象去启动多个线程。 Runnable接口的优点： 可以避免由于Java单继承带来的局限性（不占继承名额） 适合多个相同程序的代码去处
bpl文件java,----------------------[Java程序代码]public class SalesTicketpublic void printTicket()System.ou...
weixin_34873655的博客
03-18 142
----------------------[Java程序代码]public class SalesTicketpublic void printTicket()System.out.println("这是票据正文!");public class Decorator extends SalesTicketSalesTicket ticket;public Decorator(SalesTicket...
Java-网络
最新发布
2301_81543552的博客
09-14 703
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java基础：多线程原理与创建方法详解
Java基础之多线程是计算机编程中的核心概念，尤其是在并发编程领域，它允许程序同时执行多个任务或操作，从而提高系统的效率和响应能力。本文将深入探讨Java中的多线程实现以及其重要性。 **1. 线程简介** 多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值