创建多线程四种解决方式 和 多线程安全问题 解决使用 Synchronized 锁 和 Lock锁

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

创建线程的两种方式

方式一：继承Thread类

  1. 定义子类继承Thread类。
  2. 子类中重写Thread类中的run方法。
  3. 创建Thread子类对象，即创建了线程对象。
  4. 调用线程对象start方法：启动线程，调用run方法。

方式二：实现Runnable接口

  1. 定义子类，实现Runnable接口。
  2. 子类中重写Runnable接口中的run方法。
  3. 通过Thread类含参构造器创建线程对象。
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
  5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

方式三：实现Callable接口
与使用Runnable相比， Callable功能更强大些
相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

方式四：使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交
通工具。
好处：
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止

一：Synchronized 锁 的使用方法

Java对于多线程的安全问题提供了专业的解决方式：同步机制(给操作共享资源的代码加锁)

			1. 同步代码块：
		synchronized (对象){
		// 需要被同步的代码；
		}

		2. synchronized还可以放在方法声明中，表示整个方法为同步方法。
		例如：
			public synchronized void show (String name){
					….
			}

synchronized的锁是什么？

任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
同步方法的锁：静态方法（类名.class）、非静态方法（this）
同步代码块：自己指定，很多时候也是指定为this或类名.class

注意：

必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就
无法保证共享资源的安全
一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方
法共用同一把锁（this），同步代码块（指定需谨慎）

一 测试 实现Runnable接口

package com.example.test;

public class Ticket implements Runnable {

    private int tick =  100;

	
    @Override
    public void run() {

        while (true){
                if(tick > 0){
                    System.out.println(Thread.currentThread().getName()+"售出车票,车票号为：" +tick);
                    tick --;
                }
        }
    }

    public  static void  main(String[] args){
        Ticket ticket = new Ticket();

        Thread t1 =new Thread(ticket);
        Thread t2 =new Thread(ticket);
        Thread t3 =new Thread(ticket);
        
		t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

效果： 出现超卖问题
在这里插入图片描述
解决方案：加锁

方案1：同步代码块

package com.example.test;

public class Ticket implements Runnable {

    private int tick =  100;
	 /**
     *
     *  同步代码块 
     *
     */
    @Override
    public void run() {

        while (true) {
                synchronized (this){  //this 当前对象
            if (tick > 0) {
                System.out.println(Thread.currentThread().getName() + "售出车票,车票号为：" + tick);
                tick--;
              }
           }
        }
    }

    public  static void  main(String[] args){
        Ticket ticket = new Ticket();

        Thread t1 =new Thread(ticket);
        Thread t2 =new Thread(ticket);
        Thread t3 =new Thread(ticket);


        t1.setName("窗口1");  //线程1
        t2.setName("窗口2");  //线程2
        t3.setName("窗口3");  //线程3

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

    }
}

效果：
在这里插入图片描述

方案2：同步方法

package com.example.test;

public class Ticket implements Runnable {

		private static int tick =  100;
	

    /**
     *
     *  同步方法
     *
     */

    @Override
    public void run() {

        while (true) {
            show();;
        }
    }

    private static synchronized void show(){
        if (tick > 0) {
            System.out.println(Thread.currentThread().getName() + "售出车票,车票号为：" + tick);
            tick--;
        }
    }

    public  static void  main(String[] args){
        Ticket ticket = new Ticket();

        Thread t1 =new Thread(ticket);
        Thread t2 =new Thread(ticket);
        Thread t3 =new Thread(ticket);


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }

效果：
在这里插入图片描述
二 测试 继承Thread 类

package com.example.test;

public class TicketTest extends Thread {

    private  int tick =  100;

    @Override
    public void run() {

        while (true) {
            if (tick > 0) {
                System.out.println(Thread.currentThread().getName() + "售出车票,车票号为：" + tick);
                tick--;
              }
           }

    }

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


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }


}

运行效果：出现超卖问题
在这里插入图片描述
解决方案：加锁

方案1：同步方法

package com.example.test;

public class TicketTest extends Thread {

    private static int tick =  100;

    @Override
    public void run() {

        while (true) {
            show();;
        }
    }

    private static synchronized void show(){
        if (tick > 0) {
            System.out.println(Thread.currentThread().getName() + "售出车票,车票号为：" + tick);
            tick--;
        }
    }

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


        t1.setName("窗口1"); //线程1
        t2.setName("窗口2"); //线程2
        t3.setName("窗口3"); //线程3

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

    }


}

package com.example.test;

import java.awt.*;

public class TicketTest extends Thread {

    private static int tick =  100;

    /**
     *
     *  同步代码块
     *
     */


   @Override
    public void run() {

        while (true) {
            synchronized (TicketTest.class){  //TicketTest.class 当前类.class 
            if (tick > 0) {
                System.out.println(Thread.currentThread().getName() + "售出车票,车票号为：" + tick);
                tick--;
              }
           }
        }
    }

  

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


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }


}

效果：
在这里插入图片描述
二 Lock(锁)

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

public String class {
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        lock.lock(); //加锁 
        try{
            //保证线程安全的代码;
        }
        finally{
            lock.unlock(); //解锁
        }
    }
}

三 测试 实现 Callable接口

package com.example.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TicketTest2 implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i=0 ;i <100 ;i++){
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+"---"+i);
                sum+=i;
            }

        }

        return sum;
    }

    public  static void  main(String[] args) throws ExecutionException, InterruptedException {
        TicketTest2 ticket = new TicketTest2();

        FutureTask futureTask = new FutureTask(ticket);

        futureTask.run();  //启动

        System.out.println(futureTask.get()); //获取sum值

    }
}

效果：
在这里插入图片描述
四 测试 使用线程池

package com.example.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.LinkedBlockingQueue;

/**
 * @des 线程池的简单实现(可扩展)
 */
public class ThreadPool {
    private static final Logger logger = LoggerFactory.getLogger(ThreadPool.class);
    private final int poolSize;
    private final LinkedBlockingQueue queue;
    private final PoolWorker[] runable;

    public ThreadPool(int poolSize) {
        this.poolSize = poolSize;
        queue = new LinkedBlockingQueue();
        runable = new PoolWorker[poolSize];
        for (int i = 0; i < poolSize; i++) {
            runable[i] = new PoolWorker();
            new Thread(runable[i], "pool-" + i).start();
        }
    }

    public void execute(Runnable task) {
        synchronized (queue) {
            queue.add(task);
            queue.notify();
        }
    }

    private class PoolWorker implements Runnable {
        @Override
        public void run() {
            Runnable task ;

            while (true) {
                synchronized (queue) {
                    while (queue.isEmpty()) {
                        try {
                            queue.wait();
                        } catch (Exception e) {
                            logger.info("exception in queue waiting :{}",e.getMessage());
                        }
                    }
                    task = (Runnable) queue.poll();
                }
                try {
                    task.run();
                } catch (RuntimeException e) {
                    logger.info("run exception : {}", e.getMessage());
                }

            }
        }
    }

}

class ThreadPoolMain {
    public static void main(String[] args) {
        ThreadPool pool = new ThreadPool(5);
        int MaxSize = 100;
        for (int i = 0; i < MaxSize; i++) {
            pool.execute(() -> System.out.println(Thread.currentThread()));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

效果： 线程池原文 https://cloud.tencent.com/developer/article/1494618
在这里插入图片描述

jq1223
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
解决多线程安全问题
weixin_55782195的博客
05-18 597
解决多线程安全问题的方案： 一、使用同步代码块 格式：synchronized(锁对象){ 可能出现线程安全问题的代码（访问了共享数据的代码） } 注意：线程中的锁对象，可以使用任意的对象 必须保证多个线程使用的锁对象是同一个 锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行 总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步 二、使用同步方法 步骤：把访问共享数据的代码抽取出来，放到一个方法中 在方法上添加synchronized修饰符 格式： 修饰符 synchron
线程安全问题的原因及解决方案
qq_64421953的博客
03-25 3284
线程安全问题：简单来说，就是在多线程的调度下，导致出现了一些随机性，随机性使代码出现 了一些bug =>线程不安全 造成线程不安全的原因有哪些呢？ 1）抢占式执行，调度过程随机（也是万恶之源，无法解决） 2）多个线程同时修改同一个变量（可以适当调整代码结构，避免这种情况） 3）针对变量的操作，不是原子的（加锁，synchronized) 4)内存可见性，一个线程频繁读，一个线程写（使用volatile） 5）指令重排序（使用synchronized) 解决方法： 1）使用synchro
多线程安全问题以及解决方式
m0_51127483的博客
09-04 1955
因为每条语句执行都需要时间的，当某一线程抢占到CPU执行权时，便进入 run 方法执行到 if 语句，还没来得及对共享数据进行操作，就失去了CPU的执行权，被其他线程抢占。等再次获得CPU执行权并继续对共享数据进行操作时，可能此时共享数据已经不满足执行条件了，但是还得继续执行。这样就出现了安全问题。
线程安全问题的原因和解决方案
qq_55072036的博客
07-11 506
我们的预期是，当t2修改了flag的值之后，使flag不再为0，此时跳出循环，线程t1结束。这里我们也发现，说是保证原子性，不是让这里的三个操作一次执行完成，也不是这三步操作过程中不进行调度，而是让其他想操作的线程阻塞等待了。根据比较结果，来进行下一步的操作。总的来说，就是wait和notify规定了t1和t2线程的执行顺序，因此也就使t1和t2的执行有了顺序，解决了抢占式执行，随机调度。我们要注意的是，虽然我们的wait是阻塞在了synchronized代码块里了，但是实际上，这里的阻塞是释放了锁的。
多线程冲突的解决——锁
weixin_45627369的博客
07-17 2163
多个线程可以共享该进程对应的资源，所以需要加锁保证多线程在共享资源时，只有一个线程能访问，避免因资源竞争而导致数据错乱锁的选择加锁的成本开销分析业务场景中访问共享资源的方式考虑并发访问共享资源时的冲突概率。......
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
Java多线程之死锁的出现和解决方法
08-29
Java多线程之死锁的出现和解决方法 死锁是指多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。...死锁是多线程编程中一个常见的问题，解决死锁需要我们了解死锁的出现原因和解决方法。
Java Lock锁多线程中实现流水线任务
08-19
Java提供了多种方式来解决这些问题，包括使用synchronized关键字、Lock接口和Atomic变量等。在本文中，我们将主要介绍如何使用Java Lock锁来实现流水线任务。 什么是流水线任务？ 流水线任务是指一系列互相依赖的...
java多线程和锁，用于学习参考
09-09
Java多线程与锁是Java并发编程中的核心概念，它们...综上所述，Java多线程和锁是解决并发问题的关键，它们涉及线程创建、管理、同步和通信等多个方面。通过深入学习和实践，开发者能够构建出更加稳定、高效的并发程序。
多线程之线程安全问题及解决方案
m0_64986499的博客
04-24 720
本篇博客主要介绍多线程中经常出现的线程安全问题及其解决方案。
总结线程安全问题的原因和解决方案
LYJbao的博客
09-07 949
一、什么是线程安全？ 二、线程不安全带来的问题举例： 三、线程不安全的原因总结： 四、解决方案 1、同步代码块 2、同步方法 3、静态同步方法 4、加锁Lock解决问题
多线程安全问题原理和 4 种解决办法
u012181546的博客
12-17 433
单窗口卖票一个窗口 (单线程) 卖 100 张票没有问题单线程程序是不会出现线程安全问题的多个窗口卖不同的票3 个窗口一起卖票，卖的票不同，也不会出现问题多线程程序，没有访问共享数据，不会产生问题多个窗口卖相同的票3 个窗口卖的票是一样的，就会出现安全问题多线程访问了共享的数据，会产生线程安全问题。
多线程编程的安全问题和解决措施
yahid的博客
05-02 956
由于多线程并发执行，导致结果出错，我们称这种线程是不安全的。
[多线程]中线程安全问题及其解决策略
m0_73609313的博客
01-30 831
线程不安全的原因有哪些?如何根据原因解决线程不安全的问题?......看完这篇你会有所收获....
【多线程-安全性问题的解决】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
04-27 448
多线程的安全性问题解析 我们在使用多线程的时候，可以进行异步操作提高我们程序执行的效率，比如，我们一个页面需要3个接口，后端返回的时候将这个三个接口统一成一个接口执行，这三个接口在这个大接口中，如果按串行的方式执行，那么时间就是这三个接口所需时间之和，如果我们采用多线程的方式，那么返回的时间取决于这三个接口中所用时间最大的接口。 我们再来看一下他的问题。 package com.broky.multiThread.safeThread; /** * @author zxd * @date 2022-
Java基础~Java线程同步
feizuiku0116的博客
03-15 359
一、线程同步的核心思想 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。 二、方式一：同步代码块 作用：把出现线程安全问题的核心代码给上锁。 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求：理论上，锁对象只要对于当前同时执行的线程来说是同一个对象即可 三、方式二：同步方法 一、介绍 作用：把出现线程安全问题的核心方法给上锁。
【多线程】线程安全问题及解决方法
最新发布
weixin_62848751的博客
07-23 973
而load操作时间开销很大，远远高于cmp ，此时CPU有个大胆的操作，将load操作优化了，就导致只有第一次读取flag的值的时候t1线程会从主存中进行读取，之后则在本地内存进行读取，这就会导致当t2线程修改flag的值并同步到主存的时候，t1线程并没有读取到更新的值，这和我们上述提到过的Java内存模型对应，当我们给flag变量加上volatile关键字的时候问题就解决了，这是由于加了volatile关键字的变量，会指示JVM每次读取这个变量的时候都需要从主存中进行读取。
【多线程基础】 一文详解线程安全
热门推荐
书生-w的博客
03-21 2万+
如果说在多线程环境下代码运行的结果是符合我们预期的,即该代码在单线程中运行得到的结果,那么就说说这个程序是线程安全的,否则就是线程不安全的.
Java多线程：死锁防范与Lock锁的应用
在Java多线程编程中，死锁是一种常见的并发问题，当多个线程相互等待对方释放资源而陷入僵局时，就会发生死锁。死锁通常由以下原因导致： 1. **线程之间的资源竞争**：当两个或更多线程各自持有部分资源，并且都在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jq1223

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值