Java多线程及synchronized的运用代码演示加详细注释

最新推荐文章于 2023-04-05 12:59:47 发布
最新推荐文章于 2023-04-05 12:59:47 发布
阅读量244 收藏
点赞数
分类专栏： 多线程 synchronized 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xia1140418216/article/details/107822095
版权

对某个对象加锁

/**

  • synchronized关键字
  • 对某个对象加锁
    */
    public class T {
    private int count = 10;
    private Object o = new Object();
    public void m(){
    //任何线程要执行下面代码，必须先拿到o锁
    synchronized (o){
    count–;
    System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    }
    }

对当前对象加锁(一)

/**

  • synchronized关键字
  • 对某个对象加锁
    */
    public class T {
    private int count = 10;
    public void m(){
    //任何线程要执行下面的代码，必须先拿到this的锁
    synchronized (this){
    count–;
    System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    }
    }

对当前对象加锁(二)

/**

  • synchronized关键字
  • 对某个对象加锁
    */
    public class T {
    private int count = 10;
    //同等于在方法的代码执行要synchronized(this)
    public synchronized void m(){
    count–;
    System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    }

对当前对象加锁(三)

/**

  • synchronized关键字
  • 对某个对象加锁
    */
    public class T {
    private static int count = 10;
    //这里等同于synchronized(xxx.T.class)
    public synchronized static void m(){
    count–;
    System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    public static void ms(){
    synchronized (T.class){
    count–;
    }
    }
    }

synchronized使用案例

/**

  • 实验结果:在run方法如果不加上synchronized，会产生线程抢占，

  • 如果加上就确保了线程运行的原子性，先执行的执行，后执行的等待。
    */
    public class T implements Runnable {

    private int count = 10;

    @Override
    public /synchronized/ void run() {
    count–;
    System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
    T t = new T();
    for (int i = 0; i < 5; i++){
    new Thread(t, “Thread” + i).start();
    }
    }
    }

在一个对象一面两个方法加不加synchronized修饰的影响

/**

  • 实验结果:此案例说明加synchronized修饰后的线程对象，

  • 和不加synchronized修饰，两者同时运行并不冲突。
    */
    public class T {
    public synchronized void m1(){
    System.out.println(Thread.currentThread().getName() + " m1 start…");
    try {
    Thread.sleep(10000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + " m1 end…");
    }

    public void m2(){
    try {
    Thread.sleep(5000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + " m2…");
    }

    public static void main(String[] args) {
    T t = new T();
    //语法有点叼
    new Thread(()->t.m1(),“t1”).start();
    new Thread(()->t.m2(),“t2”).start();

     //和上面结果一样
 //new Thread(t::m1, "t1").start();
 //new Thread(t::m2, "t2").start();

    }
    }

脏读以及解决方法

/**

  • 脏读

  • 实验结果:实验结果为0.0。

  • 解决方法:确保读写都加上synchronized，保证原子性。
    */
    public class Account {
    String name;
    double balance;

    public synchronized void set(String name, double balance){
    this.name = name;
    //这里加上间隔时间的意义在于模拟线程被其他线程进行调用
    try {
    Thread.sleep(2000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    this.balance = balance;
    }

    public /synchronized/ double getBalance(String name){
    return this.balance;
    }

    public static void main(String[] args) {
    Account account = new Account();
    new Thread(()->account.set(“xipiker”, 21.0)).start();

     try {
     TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }

 System.out.println(account.getBalance("xipiker"));

    }
    }

synchronized获得的锁可重入

/**

  • 一个同步方法可以调用另一个同步方法，一个线程已经拥有某个对象的锁，

  • 再次申请的时候仍然会得到该兑现的锁。也就是说synchronized获得的

  • 锁是可重入的。
    */
    public class T {
    synchronized void m1(){
    System.out.println(“m1 start…”);
    try {
    TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    m2();
    }

    synchronized void m2(){
    try {
    TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(“m2 start…”);
    }

    public static void main(String[] args) {
    T t = new T();
    new Thread(()->t.m1(), “t1”).start();
    }
    }

子类调用父类的同步方法

/**

  • 子类调用父类的同步方法
    */
    public class T {
    synchronized void m(){
    System.out.println(“m start”);
    try {
    TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(“m end”);
    }

    public static void main(String[] args) {
    new TT().m();
    }
    }

class TT extends T{
synchronized void m(){
System.out.println(“child m start”);
super.m();
System.out.println(“child m end”);
}
}

程序运行出现异常，默认情况锁会被释放

/**

  • 程序在执行过程中，如果出现异常，默认情况下锁会被释放。
  • 所以，在并发处理过程中，有异常要多加小心，不然可能会发生不一致情况。
  • 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，
  • 这时候如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，
  • 有可能会访问到异常产生时的数据。因此要非常小心的处理同步业务逻辑中的异常。
  • 实验结果:锁被释放了，原子性不存在了，第二个线程接着第一个线程继续执行。
    */

public class T {
int count = 0;
synchronized void m(){
System.out.println(Thread.currentThread().getName() + " start…");
while (true){
count++;
System.out.println(Thread.currentThread().getName() + " count = " + count);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//这里我们模拟异常
//此处抛出异常，锁将释放，要想不被释放，可以在这里进行catch，然后让循环继续
if (count == 5){
int i = 1/0;
}
}
}
public static void main(String[] args) {
T t = new T();
Runnable r = new Runnable() {
@Override
public void run() {
t.m();
}
};

    new Thread(r, "t1").start();

    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(r, "t2").start();
}
}

volatile使一个变量在多个线程间可见

/**

  • volatile关键字，使一个变量在多个线程间可见。

  • 例子: A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道

  • 使用volatile关键字，会让所有线程都会读到变量的赋值。

  • 在下面代码中running是存在于堆内存的t对象中，当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，

  • 在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行。

  • 使用volatile，将会强制所有线程都去堆内存中读取running的值。

  • volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized。
    */
    public class T {
    volatile boolean running = true;
    void m(){
    System.out.println(“m start…”);
    while (running){

     }
 System.out.println("m end!");

    }

    public static void main(String[] args) {
    T t = new T();
    new Thread(t::m, “t1”).start();

     try {
     TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }

 t.running = false;

    }
    }

volatile并不能保证原子性

/**

  • volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能代替synchronized。

  • 实验结果:多个线程间比如A线程执行中的count为100，B线程计算的A的count在加一为101，然后轮到A执行时他的count值时应该count结果为102，

  • 但是执行了为101，所以原本count的102值又被清回101。
    */
    public class T {
    volatile int count = 5;
    void m(){
    for(int i = 0; i < 1000; i++)
    count++;
    }

    public static void main(String[] args) {
    T t = new T();
    List threads = new ArrayList();

     for (int i = 0; i < 10; i++){
     threads.add(new Thread(t::m, "Thread-" + i));
 }

 threads.forEach((o)->o.start());

 threads.forEach((o)->{
     try {
         o.join();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 });
 System.out.println(t.count);

    }
    }

使用AtomXXX类，确保变量的原子性

/**

  • 确保变量的原子性，更加高效的方法可以使用AtomXXX类。

  • AtomXXX类本身方法都是原子性，但不能保证多个方法连续调用是原子性。
    */
    public class T {
    AtomicInteger count = new AtomicInteger(0);
    void m(){
    for (int i = 0; i < 10000; i++)
    //if count.get() < 1000 ->这里如果执行那么就不在具有原子性了，
    // 因为可能会有线程执行到count.get() < 1000里面去，而又有的线程执行了下面的++操作。
    count.incrementAndGet(); //count++
    }

    public static void main(String[] args) {
    T t = new T();
    List threadList = new ArrayList();
    for (int i = 0; i < 10; i++){
    threadList.add(new Thread(t::m, “thread-” + i));
    }

     threadList.forEach((o)->o.start());

 threadList.forEach((o)->{
     try {
         o.join();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 });
 System.out.println(t.count);
 }
 }
夏小白.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程synchronized关键字详解(六)
09-03
主要介绍了Java 多线程synchronized关键字详解(六)的相关资料,需要的朋友可以参考下
Java多线程同步Synchronized深入解析
12-22
同步的概念： 　同步分为同步方法和同步块两种... 　无论你将Synchronized加在方法前还是加在一个变量前，其锁定的都是一个 类对象。每一个对象都只有一个锁与之相关联。 　下例中分情况的列举各种情况下的同步效果
java线程-synchronized详解
BASK2311的博客
02-03 2071
synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized 翻译为中文的意思是同步，也称之为”同步锁“。synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。
Java多线程（二）——synchronized 详解
m0_45198397的博客
01-05 4859
java多线程
JAVA基础 - Synchronized详解
记录并分享
06-11 353
JAVA中提供了synchronized关键字，将可能引发安全问题的代码包裹在synchronized代码块中，表示这些代码需要进行线程同步。
Java关键字之synchronized详解【Java多线程必备】
最新发布
Mr.绵羊的知识星球
04-05 5430
1. synchronized详解 2. synchronized使用注意事项和案例
lombok 基础注解之 @Synchronized
用善良的眼光看世界
11-03 1627
最全的 lombok 注解详情（随着版本不定时更新） 一、注解介绍 作用于方法，可以替换 synchronize 关键字或 lock 锁 二、属性介绍 value：指定锁对象，当锁对象不存在时，则编译不通过，默认为 “” 三、实战演练 public class 唐嫣 { public final String NAME = "唐嫣"; @Synchronized(value = "NAME") // 对应字段 NAME public void name() { System.out.pri
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
java基本教程之synchronized关键字 java多线程教程
09-04
主要介绍了java的synchronized原理、synchronized基本规则、synchronized方法 和 synchronized代码块、实例锁和全局锁
synchronized的几种示例
10-24
synchronized的几种示例研究,方法加锁，代码块加锁（this和对象）以及静态方法加锁的示例和效果。基本上包含了synchronized的几种常用的方式。
@synchronized 注解和java关键字synchronized
TuoLinHuai的博客
11-14 5076
synchronized：在方法的返回值前加上该关键字synchronized ，一次只能有一个线程进入该方法；（互斥锁，锁住的是当前对象，调用该方法的当前对象，相当于 this ; 只允许当前对象运行） @synchronized ：@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一...
Java synchronized详解
杨宇昌的博客
03-17 8670
java并发 synchronized详解
JavaSynchronized详解
weixin_44115091的博客
02-15 186
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该object中的非加锁代码块。
synchronized详解
qq1071643762的博客
04-29 413
多线程系列文章目录 多线程编程中，有可能会出现多个线程同时访问同一个共享、可变资源的情况，这个资源我们称之其为临界资源；这种资源可能是：对象、变量、文件等。 共享：资源可以由多个线程同时访问。 可变：资源可以在其生命周期内被修改 引出的问题：由于线程执行的过程是不可控的，所以需要采用同步机制来协同对对象可变状态的访问！ 文章目录多线程系列文章目录一、如何解决线程并发安全问题？二、synchronized原理详解三丶synchronized底层原理Monitor监视器锁什么是monitor？对象的内存布局
Java线程同步synchronized
ximen250的专栏
07-26 688
三个窗口卖票的程序。 多线程共同操作一个对象的变量。锁是对象级别的，一个被synchronized修饰的代码块或方法一个时刻只能被一个线程执行。 package fire; public class Seller1 extends Thread{ Ticket t = null; public Seller1(Ticket t){ this.t=t; } public voi
JAVA 同步锁
cimbala的博客
02-02 2429
同一个订单才加同步锁，不同订单可并行。
【Lombok】@Synchronized | 如何优雅的添加Synchronized锁
猫巳的博客
12-16 1747
文章目录一、简介二、示例比较1. Lombok 写法2. Java 标准写法三、支持的配置项四、附属说明参考文献 一、简介 @Synchronized是synchronized方法修饰语的一个更安全的变体。和synchronized一样，该注解只能用于静态和实例方法。它的操作与synchronized关键字类似，但它锁定的对象不同。关键字锁定了这个对象，但注解锁定了一个名为$lock的字段，它是私有的。 如果你愿意，你可以自己创建这些锁。如果你已经自己创建了$lock和$LOCK字段，当然就不会再生成它们。
Java 之 synchronized 详解
weixin_34297300的博客
06-21 235
一、概念 synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。 锁机制有如下两种特性： 互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。 可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的（...
java多线程锁synchronized
03-16
Java中的synchronized关键字可以用于实现多线程锁，保证多个线程对共享资源的访问是互斥的。当一个线程获取了锁，其他线程就必须等待该线程释放锁后才能继续访问共享资源。synchronized可以用于方法和代码块，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值