synchronized同步锁

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

synchronized同步锁

synchronized同步锁

在多线程运行环境中，因为存在资源共享与竞争，为了合理分配资源以及公平地使用资源，所以需要锁。

多线程情况下，不设置锁出现的问题

public class Test02 {
    public static void main(String[] args) {
        Thread add = new AddThread();
        Thread dec = new DecThread();

        //启动线程
        add.start();
        dec.start();

        // 插队		
        try {
            add.join();
            dec.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Counter.count);
    }
}

class Counter{
    public static int count = 0;	
}

class AddThread extends Thread{
    @Override
    public void run() {

        for(int i = 0 ;i< 10000; i++) {
            Counter.count += 1;
        }		
    }	
}

class DecThread extends Thread{
    @Override
    public void run() {
        for(int i = 0 ;i< 10000; i++) {
            Counter.count -= 1;
        }		
    }
}

代码执行结果如下：

在这里插入图片描述
结果出现异常的图解：

在这里插入图片描述

小结：按照正常的逻辑，从0 加10000次，在减少10000次，最后得到的值应该为0 ，但是由于多线程并发执行，导致数据不准确，相互之间产生冲突，使得最后获取的结果不是理想的结果，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了唯一性和准确性。（优化代码 在 synchronized 锁 用法 中）

synchronized原理

每一个Java对象都可以关联一个Monitor对象，当使用synchronized关键字的时候，该对象就会与一个Monitor对象关联，并且通过monitorenter/monitorexit指令实现监视器机制。

监视器(monitor)

在这里插入图片描述

监视器的获取步骤
  • 执行monitorenter指令，判断当前monitor监视器的线程进入数量：如果为0，则该线程直接进入监视器owner，代表该线程拥有监视器，同时进入数设置为1；
  • 如果线程已经拥有该monitor监视器，重新进入，则进入数+1；如果其它线程尝试获取监视器，则进入阻塞区，线程进入阻塞状态，直到监视器的进入数为0；
  • 执行monitorexit指令，进入数-1

synchronized 锁使用

synchronized 的基本用法有以下 3 种：

  • 修饰静态方法
  • 修饰实例方法
  • 修饰代码块()
代码块

通过一个公共对象，作为“锁”

1.创建一个Object类型的公共对象，作为锁实现
class Counter{
    //方式1：创建一个公共对象
    public static int count = 0;	
    //锁 
    public static final Object LOCK = new Object();
}

class AddThread extends Thread{
    @Override
    public void run() {
        for(int i = 0 ;i< 10000; i++) {
            //方式1
            synchronized (Counter.LOCK) {
                Counter.count += 1;
            }
        }
    }
}
class DecThread extends Thread{
    @Override
    public void run() {
        for(int i = 0 ;i< 10000; i++) {
            //方式1
            synchronized (Counter.LOCK) {
                Counter.count -= 1;
            }
        }
    }
}
  1. 使用线程安全的类型来存储内容，不用自己实现锁（只具备原子性的AtomicInteger）
class Counter{
    //只具备原子性的AtomicInteger
    public static AtomicInteger count =new AtomicInteger();
}

class AddThread extends Thread{
    @Override
    public void run() {
        for(int i = 0 ;i< 10000; i++) {
            Counter.count.incrementAndGet(); //自增
        }
    }
}
class DecThread extends Thread{
    @Override
    public void run() {
        for(int i = 0 ;i< 10000; i++) {
            Counter.count.decrementAndGet();  //自减
        }
    }
}

在这里插入图片描述

添加synchronized锁以后，解决了同步问题，这时获取的结果，就是正常的。

实例方法

通过当前对象this，作为“锁”

public void dosth1() {
    //方式1 ：使用this当前对象，作为锁
    synchronized (this) {
        System.out.println("....");
    }
}

//实例方法
// 方式2 ：使用synchronized关键字（等同于使用this作为锁）
public synchronized void dosth2() {
}
静态方法

通过当前类Class对象，作为“锁”

public static void dosth1() {
    //方式1 : 使用当前类Class对象，作为锁
    synchronized (Example2.class) {
        System.out.println("....");
    }
}

//静态方法
//方式2 ：使用synchronized关键字（等同于使用类Class对象作为锁）
public synchronized static void dosth2() {
}

案例

模拟卖票场景，此时每个窗口视为一个线程，当每卖出一张票，让子线程休眠1000毫秒，代码实现如下：

public static void main(String[] args) {

    TicketPool ticketPool = new TicketPool(20);

    new Thread(ticketPool,"窗口1").start();
    new Thread(ticketPool,"窗口2").start();
    new Thread(ticketPool,"窗口3").start();
}

class TicketPool implements Runnable {

    // 当前剩余门票数
    private int ticketNum;

    // 初始化
    public TicketPool(int ticketNum) {
        this.ticketNum = ticketNum;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始卖票了");
        synchronized (this) {
            while (true) {
                if (ticketNum <= 0) {
                    System.out.println("门票已买完。。。");
                    return;
                } else {
                    System.out.println(Thread.currentThread().getName()+"卖出一张票，" + "剩余" + --ticketNum + "张票");

                    try {						
                        // 休眠过程中，当前线程不会让出持有的（"this"）锁,此时会出现异常情况，只有一个线程在执行，剩余线程处于Blockteb阻塞状态
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    try {
                        // 计时等待过程中，当前线程会释放锁
                        this.wait(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

当子线程sleep休眠时，结果如下
在这里插入图片描述

当子线程wait等待时，结果如下

在这里插入图片描述

综上所述， 在sleep休眠过程中，当前线程不会让出持有的（“this”）锁,此时会出现异常情况，只有一个线程在执行，剩余线程处于Blockteb阻塞状态，而在wait计时等待过程中，当前线程会释放锁

锁升级（锁膨胀）

偏向(斜)锁

只有一个线程执行的场景，使用偏向锁；

轻量级锁（不能处理并发）

发生多个线程执行的场景，偏向锁升级为轻量级锁；

重量级锁

发现多个线程并发执行的场景，轻量级锁升级为重量级锁；

通过操作系统的“互斥锁”实现。互斥锁实现线程之间的切换，需要从“用户态”切换到“内核态”，付出高昂的代价，会导致性能下降。

同步时的通信

  • wait() ：必须通过 notify() / notifyAll()

  • wait(等待时间) ：达到计时时间后，自动唤醒

案例

请按照 12A 34B 56C 。。。输出

思路：将数字，和字母分开，一个线程控制数字输出，另一个线程控制字母输出，即输出数字后，数字线程进入等待，同时唤醒字母线程，反之，输出字母时，字母程进入等待，同时唤醒数字线程。

具体实现如下：

Main
public static void main(String[] args) {
    Object lock = new Object();

    Thread t1 = new Thread(new Number(lock),"数字");
    Thread t2 = new Thread(new Character(lock),"字母");

    t1.start();
    t2.start();
}
字母类
public class Character implements Runnable {

	private final Object LOCK;

	public Character(Object lock) {
		LOCK = lock;
	}

	@Override
	public void run() {
		synchronized (LOCK) {
			for (char c = 'A'; c <= 'Z'; c++) {

				System.out.print(c);
				//唤醒处于等待状态的所有线程（数字线程）
				LOCK.notifyAll();
				if(c < 'Z' ){
					try {
						//字母线程进入等待
						LOCK.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
    }
}
数字类
public class Number implements Runnable {
	
	private final Object LOCK;	

	public Number(Object lock) {
		LOCK = lock;
	}

	@Override
	public void run() {		
		synchronized (LOCK) {
			for(int i = 1 ;i<= 52;i++) {
				
				if(i % 2 == 1) {
					System.out.print(" ");
				}
				System.out.print(i);
                
				if(i % 2 == 0) {
					//唤醒处于等待状态的所有线程（字母线程）
					LOCK.notifyAll();
					try {
						// 数字线程进入等待
						LOCK.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

结果如下：

在这里插入图片描述

codeMonkey-吉
关注
专栏目录
Synchronized 同步锁详解
qq_56263094的博客
07-21 1545
Synchronized是JAVA的关键字，是基于JVM层面的独占式的悲观锁，同时也属于可重入锁经常来用于解决多个线程之间访问访问资源的同步性，保证在同一时刻只有一个线程访问这个资源。
Synchronized同步锁
qq_49194786的博客
09-08 1822
有关synchronized同步锁的介绍！
synchronized原理
最新发布
m0_62055442的博客
09-05 996
然而，如果在你进入房间的过程中，另一个人也尝试进入同一个房间，并且他发现门没有上锁，那么他会迅速将门锁上，以确保房间的安全。然而，如果在使用过程中，另一个线程也尝试加锁，那么在其加锁之前，偏向锁会迅速升级为真正的加锁状态，此时另一个线程将处于阻塞等待状态。然而，由于线程需要等待锁的释放，这可能会导致线程的执行效率降低，尤其是在高并发场景下。总之，synchronized通过自旋和计数器的组合来实现高效的锁管理，既避免了长时间的阻塞，又减少了不必要的CPU资源消耗。在这种情况下，一次加一个大锁可能更加高效。
java 同步锁(synchronized)
热门推荐
lianqiangjava的专栏
10-12 7万+
java 同步锁(synchronized)
4、基本的线程同步
等风的帆
12-21 326
monitor他们是应用于同步问题的人工线程调度工具。讲其本质，首先就要明确monitor的概念，Java中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在synchronized 范围内，监视器发挥作用。当某代码并不持有监视器的使用权时（如图中5的状态，即脱离同步块）去wait或notify，会抛出java.lang.IllegalMonitorSta
基于Java synchronized同步锁实现线程交互.pdf
12-31
"基于Java synchronized同步锁实现线程交互" Java多线程能够提高CPU利用效率，但也容易造成线程不安全、线程死锁等问题。Java synchronized同步锁可以保证同一时刻只有一个线程操作同一资源，使用wait()、notify()...
【Java】synchronized同步锁详解
12-22
【Java】synchronized同步锁详解 Java 中的同步机制主要用于解决多线程环境下的数据安全问题，其中synchronized关键字是Java提供的一种内置锁，也称为监视器锁或悲观锁。synchronized可以确保在同一时刻，只有一个...
性能优化——Synchronized同步锁的优化方法
qq_36589864的博客
08-20 685
在并发编程中，多个线程访问同一个共享资源时，我们必须考虑如何维护数据的原子性。在 JDK1.5 之前，Java 是依靠 Synchronized 关键字实现锁功能来做到这点的。 Synchronized 是 JVM 实现的一种内置锁，锁的获取和释放是由 JVM 隐式实现。 到了 JDK1.5 版本，并发包中新增了 Lock 接口来实现锁功能，它提供了与 Synchronized 关键字类似的同步功能，只是在使用时需要显示获取和释放锁。 Lock 同步锁是基于 Java 实现的，而 Syn..
同步锁 （synchronized）
Dimples.
08-29 1653
 调用方法：类名.class，每一种类都有一个唯一的类对象 。   异步操作：多线程的并发操作，相当于各干各的。  同步操作：相当于一个做完，另一个再做。 锁机制：当一个线程进入同步的代码块后,就会获得锁对象的使用权。其他线          程如果执行到此处，会发现锁对象被占用，只能处于等待状态(锁池)，          当线程执行完同步的代码后或者出现异常，都会自动释放锁。 同步代...
Synchronized Lock 锁 同步
qq_30436011的博客
04-25 3265
如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。 字符串作为锁对象的参考 一、synchronized的性质 1、可重入性 官方解释：指的是同一线程的外层函数获得锁之后，内层函数可以直接再次获得该锁； 通俗解释：获得一次锁之后，如果调用其它同步方法，不需要重新获取锁，可以直接使用； 在方法1中调用方法2，两个方法都是同步方法，在获取方法1的锁之后，是可以直接调用方法2，而不需要重新获取锁，这就是可重入性，可重入性是线程范围，可以...
java 同步锁（synchronized）
weixin_33747129的博客
11-10 140
java中cpu分给每个线程的时间片是随机的并且在java中好多都是多个线程共用一个资源，比如火车卖票，火车票是一定的，但卖火车票的窗口到处都有，每个窗口就相当于一个线程，这么多的线程共用所有的火车票这个资源。如果在一个时间点上，两个线程同时使用这个资源，那他们取出的火车票是一样的（座位号一样），这样就会给乘客造成麻烦。比如下面程序： package com.dr.r...
Synchronized 同步锁
weixin_40426261的博客
11-15 169
synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重 入锁。 Synchronized 作用范围 作用于方法时，锁住的是对象的实例(this)； 2. 当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen （jdk1.8 则是 metaspace），永久带是全局共享的，因此静态方法锁相当于类的一个全局...
synchronized是同步锁吗
02-28
是的，synchronized是Java中的关键字，用于实同步锁机制。当一个方法或者一个代码块被synchronized修饰时，它变成了一个临区，同一时间只能有一个线进入该临界区执行代码，其他线程需要等待。这样可以保证多个线程在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值