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

最新推荐文章于 2024-08-29 20:28:58 发布
最新推荐文章于 2024-08-29 20:28:58 发布
阅读量183 收藏 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
关注
专栏目录
解决多线程安全问题
weixin_55782195的博客
05-18 674
解决多线程安全问题的方案： 一、使用同步代码块 格式：synchronized(锁对象){ 可能出现线程安全问题的代码（访问了共享数据的代码） } 注意：线程中的锁对象，可以使用任意的对象 必须保证多个线程使用的锁对象是同一个 锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行 总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步 二、使用同步方法 步骤：把访问共享数据的代码抽取出来，放到一个方法中 在方法上添加synchronized修饰符 格式： 修饰符 synchron
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
如何解决多线程的线程不安全问题
最新发布
huapiaoy的博客
08-29 1522
解决线程安全的思路和方法;1,使用没有共享资源的模型2.不对共享变量进行写操作3.通过加锁和一些原子操作来保证线程的顺序，可见性，和原子性。
【多线程-安全性问题的解决】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
04-27 467
多线程的安全性问题解析 我们在使用多线程的时候，可以进行异步操作提高我们程序执行的效率，比如，我们一个页面需要3个接口，后端返回的时候将这个三个接口统一成一个接口执行，这三个接口在这个大接口中，如果按串行的方式执行，那么时间就是这三个接口所需时间之和，如果我们采用多线程的方式，那么返回的时间取决于这三个接口中所用时间最大的接口。 我们再来看一下他的问题。 package com.broky.multiThread.safeThread; /** * @author zxd * @date 2022-
多线程安全解决方式
qq_23410909的博客
05-17 108
1、互斥同步：具体方案有synchronized，获得锁monitorenter将锁计数器加1，执行对象monitorexit将锁计数器减1，当锁计数器为0，锁对象释放。 java.util.concurrentJava工具类：下的并发包对应的ReentrantLock，跟synchronized很类似，配合lock()、unlock()、try/finally来使用。 2、非阻塞同步(常用C...
多线程安全问题及解决办法
fandoudou123的专栏
08-31 507
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
Java Lock锁多线程中实现流水线任务
08-19
Java提供了多种方式来解决这些问题，包括使用synchronized关键字、Lock接口和Atomic变量等。在本文中，我们将主要介绍如何使用Java Lock锁来实现流水线任务。 什么是流水线任务？ 流水线任务是指一系列互相依赖的...
java多线程和锁，用于学习参考
09-09
Java多线程与锁是Java并发编程中的核心概念，它们...综上所述，Java多线程和锁是解决并发问题的关键，它们涉及线程创建、管理、同步和通信等多个方面。通过深入学习和实践，开发者能够构建出更加稳定、高效的并发程序。
【多线程】线程安全问题及解决方法
weixin_62848751的博客
07-23 1312
而load操作时间开销很大，远远高于cmp ，此时CPU有个大胆的操作，将load操作优化了，就导致只有第一次读取flag的值的时候t1线程会从主存中进行读取，之后则在本地内存进行读取，这就会导致当t2线程修改flag的值并同步到主存的时候，t1线程并没有读取到更新的值，这和我们上述提到过的Java内存模型对应，当我们给flag变量加上volatile关键字的时候问题就解决了，这是由于加了volatile关键字的变量，会指示JVM每次读取这个变量的时候都需要从主存中进行读取。
多线程安全问题以及解决方式
m0_51127483的博客
09-04 2025
因为每条语句执行都需要时间的，当某一线程抢占到CPU执行权时，便进入 run 方法执行到 if 语句，还没来得及对共享数据进行操作，就失去了CPU的执行权，被其他线程抢占。等再次获得CPU执行权并继续对共享数据进行操作时，可能此时共享数据已经不满足执行条件了，但是还得继续执行。这样就出现了安全问题。
多线程的安全问题及解决方案
ctycsdn的博客
07-18 1522
概念 当多个线程同时共享同一个全局变量做写的操作的时候，可能会受到其他线程的干扰，就会产生线程安全问题，出现数据脏读 解决方案 核心思想：同一个时刻保证只允许单线程执行 方案 使用java锁的机制Synchronized、Lock锁和CAS无锁机制 对于代码中如果在多线程同时执行操作的情况下，可能会受到其他线程的干扰的代码采用锁的机制，在同一个时刻只能保证只有一个线程去执行，只有获取到锁之后，才能够进入该代码块执行，代码执行完之后释放锁之后其他线程去获取锁才可以执行。 没有获取到锁的线程，则一直会排队阻塞
多线程及线程安全问题解决方案
weixin_46292175的博客
03-02 596
多线程及线程安全问题解决方案 1. 多线程 1.1 多线程的优缺点 优点：1. 提升资源利用率 2. 提高用户体验 缺点： 1. 降低了其他线程的执行概率 2. 用户会感受到软件的卡顿问题 3. 增加的系统，资源压力 4. 多线程情况下的共享资源问题，线程冲突，线程安全问题 1.2 创建自定义线程类的两种方式 class Thread类 Java中的一个线程类 Thread...
【java基础】多线程安全问题解决方式
weixin_67874152的博客
04-24 684
卖票过程中出现了重票和错票的情况 (以下多窗口售票demo存在多线程安全问题)
java多线程安全解决方案_Java多线程安全问题的解决方式
weixin_29122543的博客
02-17 294
出现的原因当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错示例class Window implementsRunnable{private int ticket = 10;@Overridepublic voidrun() {while (true){if (ticket > 0){try{Thread.slee...
多线程之线程安全问题及解决方案
m0_64986499的博客
04-24 771
本篇博客主要介绍多线程中经常出现的线程安全问题及其解决方案。
Java基础~Java线程同步
feizuiku0116的博客
03-15 397
一、线程同步的核心思想 加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。 二、方式一：同步代码块 作用：把出现线程安全问题的核心代码给上锁。 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求：理论上，锁对象只要对于当前同时执行的线程来说是同一个对象即可 三、方式二：同步方法 一、介绍 作用：把出现线程安全问题的核心方法给上锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

jq1223

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

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

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

打赏作者

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

抵扣说明：

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

余额充值