2.2使用synchronized同步语句块

最新推荐文章于 2021-10-23 21:05:04 发布
最新推荐文章于 2021-10-23 21:05:04 发布
阅读量278 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bb10210521/article/details/50511733
版权

sychronized方法的弊端

如果A线程执行的sychronized方法执行一个时间比较长的任务，则B线程需要等待比较长的时间，这是可以用sychronized代码块来解决

package com.myObject;

public class Object5 {

     public void mothd() {
        System.out.println(Thread.currentThread().getName()+"开始模拟长时间任务");
        try {
            Thread.sleep(1500);
            synchronized (this){
                System.out.println("需要线程安全");
            }
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束模拟长时间任务");

    }
}

package com.test;

public class Sum{
    public static long b1;
    public static long b2;
    public static long e1;
    public static long e2;
}
package com.test;

import com.myObject.Object5;

public class Test5 {


    public static void main(String[] args) throws InterruptedException {
        final Object5 object5 = new Object5();
        final long b;
        final long e;
        Thread threadA = new Thread() {
            @Override
            public void run() {
                super.run();
                Sum.b1=System.currentTimeMillis();
                object5.mothd();
                Sum.e1=System.currentTimeMillis();
            }
        };
        Thread threadB = new Thread() {
            @Override
            public void run() {
                super.run();
                Sum.b2=System.currentTimeMillis();
                object5.mothd();
                Sum.e1=System.currentTimeMillis();
            }
        };
        threadA.setName("a");
        threadB.setName("b");
        threadA.start();
        threadB.start();
        Thread.sleep(10000);
         b=(Sum.b1>Sum.b2)?Sum.b2:Sum.b1;
         e=(Sum.e1>Sum.e2)?Sum.e1:Sum.e2;
         System.out.println((e-b)/1000);
    }
}

打印结果

b开始模拟长时间任务
a开始模拟长时间任务
需要线程安全
需要线程安全
a结束模拟长时间任务
b结束模拟长时间任务
耗时3

如果将synchronized放在方法上

package com.myObject;

public class Object5 {

    synchronized public void mothd() {
        System.out.println(Thread.currentThread().getName() + "开始模拟长时间任务");
        try {
            Thread.sleep(1500);
            {
                System.out.println("需要线程安全");
            }
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束模拟长时间任务");

    }
}

则打印结果为

a开始模拟长时间任务
需要线程安全
a结束模拟长时间任务
b开始模拟长时间任务
需要线程安全
b结束模拟长时间任务
耗时6

将任意对象作为对象监视器

现在已经知道了synchronized同步方法和synchronized（this）同步代码块，现在来研究synchronized（非this对象）同步代码块

1)在多个线程持有“对象监视器”为同一个对象时，同一时间只有一个线程可以执行synchronized（非this对象）同步代码块中的代码

package com.myObject;

public class Object1 {
    private String username;
    private String password;
    private String str = new String();

    public void setUsernamePassword(String username, String password) {
        try {
            synchronized(str){
                System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":begin");
                this.username=username;
                Thread.sleep(3000);
                this.password=password;
                System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1a extends Thread {
    Object1 object1;

    public Thread1a(Object1 object1) {
        this.object1 = object1;
    }

    @Override
    public void run() {
        super.run();
        object1.setUsernamePassword("a", "aa");
    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1b extends Thread {
    Object1 object1;

    public Thread1b(Object1 object1) {
        this.object1 = object1;
    }

    @Override
    public void run() {
        super.run();
        object1.setUsernamePassword("b", "bb");
    }
}

package com.test;

import com.myObject.Object1;
import com.myThread.Thread1a;
import com.myThread.Thread1b;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {

        // 测试1
        Object1 object1 = new Object1();
        Thread1a thread1a = new Thread1a(object1);
        thread1a.setName("a");
        thread1a.start();
        Thread1b thread1b = new Thread1b(object1);
        thread1b.setName("b");
        thread1b.start();

    }
}

打印结果

1452738622275 a:begin
1452738625275 a:end
1452738625275 b:begin
1452738628275 b:end

2）使用synchronized（非this对象）同步代码块，若线程执行的方法或者代码块所持有的监视对象不同，则执行是异步的

package com.myObject;

public class Object2 {
    private String username;
    private String password;
    private String str = new String();

    public void setUsernamePassword(String username, String password) {
        try {
            synchronized(str){
                System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":begin");
                this.username=username;
                Thread.sleep(3000);
                this.password=password;
                System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
    }

    synchronized public void setUsernamePassword2(String username, String password) {
        try {
            System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":begin");
            this.username=username;
            Thread.sleep(3000);
            this.password=password;
            System.out.println(System.currentTimeMillis()+" "+Thread.currentThread().getName()+":end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

package com.myThread;

import com.myObject.Object2;

public class Thread2b extends Thread {
    Object2 object2;

    public Thread2b(Object2 object2) {
        this.object2 = object2;
    }

    @Override
    public void run() {
        super.run();
        object2.setUsernamePassword2("b", "bb");
    }
}

package com.myThread;

import com.myObject.Object2;

public class Thread2a extends Thread {
    Object2 object2;

    public Thread2a(Object2 object2) {
        this.object2 = object2;
    }

    @Override
    public void run() {
        super.run();
        object2.setUsernamePassword("a", "aa");
    }
}

package com.test;

import com.myObject.Object2;
import com.myThread.Thread2a;
import com.myThread.Thread2b;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {

        // 测试2
        Object2 object2 = new Object2();
        Thread2a thread2a = new Thread2a(object2);
        thread2a.setName("a");
        thread2a.start();
        Thread2b thread2b = new Thread2b(object2);
        thread2b.setName("b");
        thread2b.start();

    }
}

打印结果

1452740150310 a:begin
1452740150310 b:begin
1452740153310 a:end
1452740153311 b:end

synchronized（x）结论

1）多个线程同时执行synchronized（x）同步代码块，线程呈同步
2）当某线程持有x对象，而其他线程执行x对象中的synchronized同步方法或者synchronized（this）同步代码块，线程呈同步

针对第二点，有以下实例

package com.myObject;

public class Object3a {

    public void setObject(Object3a object3a, Object3b object3b) {
        try {
            synchronized (object3b) {
                System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":begin");
                Thread.sleep(3000);
                System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":end");

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.myObject;

public class Object3b {

    synchronized public void print() {
        try {
            System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":begin");
            Thread.sleep(3000);
            System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

     public void print2() {
        try {
            synchronized(this){
            System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":begin");
            Thread.sleep(3000);
            System.out.println(System.currentTimeMillis() + " "+ Thread.currentThread().getName() + ":end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

package com.myThread;

import com.myObject.Object3a;
import com.myObject.Object3b;

public class Thread3a extends Thread {
    Object3a object3a;
    Object3b object3b;

    public Thread3a(Object3a object3a,Object3b object3b) {
        this.object3a = object3a;
        this.object3b = object3b;
    }

    @Override
    public void run() {
        super.run();
        object3a.setObject(object3a, object3b);
    }
}

package com.test;

import com.myObject.Object3a;
import com.myObject.Object3b;
import com.myThread.Thread3a;
import com.myThread.Thread3b;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {

        Object3a object3a = new Object3a();
        Object3b object3b = new Object3b();
        Thread3a thread3a = new Thread3a(object3a,object3b);
        thread3a.setName("a");
        thread3a.start();
        Thread3b thread3b = new Thread3b(object3b);
        thread3b.setName("b");
        thread3b.start();

    }
}

package com.myThread;

import com.myObject.Object3b;

public class Thread3b extends Thread {
    Object3b object3b;

    public Thread3b(Object3b object3b) {
        this.object3b = object3b;
    }

    @Override
    public void run() {
        super.run();
        //测试1
//      object3b.print();
        //测试2
        object3b.print2();

    }
}

测试1结果打印

1452743633845 a:begin
1452743636845 a:end
1452743636845 b:begin
1452743639846 b:end

测试2结果打印

1452743674541 a:begin
1452743677542 a:end
1452743677542 b:begin
1452743680543 b:end

envieol
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Synchronized同步关键字和Lock锁
xp_xpxp的博客
07-26 356
1.Synchronized同步关键字 1.1.Synchronized同步关键字简介 synchronized是属于JVM层面的一个关键字,底层是通过一个monitor对象(/管程对象)来完成,由于wait()/notify()等方法也依赖于monitor对象,所以只有在同步的块或者方法中才能调用wait/notify等方法 1.2.同步代码块中synchronized底层实现 ...
13 - synchronized 同步互斥锁
pizicai007的博客
06-25 747
并发编程之 Synchronized 关键字：解决原子性1. Synchronized 使用1.1 线程安全问题1.2 Synchronized 概念1.3 Synchronized 的作用范围2. Synchronized 原理2.1 同步代码块2.2 同步方法2.3 Monitor2.3.1 Monitor 是什么2.3.2 Monitor 如何实现线程同步3. 解决三大问题：原子性、可见性和有序性3.1 保证原子性3.2 保证有序性3.3 保证可见性 1. Synchronized 使用 1.1 线程
2.2synchronized同步语句块
weixin_30385925的博客
12-06 65
使用synchronized虽然能够避免不同步的现象出现，但是也会出现弊端，比如代码执行时间过长，那么其他线程就必须等待该线程执行完毕释放锁之后才能拿到锁。 面对这种问题可以使用同步代码块来解决。 2.2.1synchronized方法的弊端： 任务类： public class Task { private String getData1; private Str...
Java多线程笔记（二）--synchronized同步语句块
云端做梦
07-22 292
亲爱的观众朋友们，你们好！这是多线程笔记的第二篇文章，这一章主要是学习一下对象以及变量的并发访问。 学习完本章主要掌握以下技术点： synchronized对象监视器Object时的使用。 synchronized对象监视器Class时的使用。 非线程安全是如何出现的。 关键字volatile的主要作用。 关键字volatile与 synchronized...
多线程编程-synchronized语句块（二）
lin20080410的专栏
01-12 223
2.2 synchronized 同步语句块 2.2.1 使用synchronized同步方法时，如果一个线程调用同步方法执行一个长时间的任务，那么其他线程必须等待很长时间，这时用同步语句块可提高执行效率。 同步方法耗时测试代码： public class Task { private String getData1; private String getData2; publ
Java多线程(三) synchronized(this)同步语句块
Java Spring Elasticsearch
11-08 664
synchronized （this）同步语句块1. 一半异步，一半同步1.1 Task1.2 ThreadA1.3 ThreadB1.4 Test1.5 运行结果2. synchronized代码块间的同步性2.1 ObjectService2.2 ThreadA2.3 ThreadB2.4 ThreadC2.5 Test2.6 运行结果 1. 一半异步，一半同步 不在synchronized块...
java线程学习之线程同步synchronized
做一个有思想的技术人
03-29 477
synchronized学习线程安全性线程同步synchronized介绍对象锁和类锁synchronized使用 线程安全性 java支持多个线程访问同一个对象或者对象的成员变量，在并发编程中，这种被多个线程并发访问的资源称为临界资源。并且每个线程可以拥有对这个临界资源的拷贝，所以在程序执行过程中看到的变量不一定是最新的，无论何时只要有多于一个的线程访问给定的共享变量，而且其中某个线程会写入该变...
关键字synchronized的使用
forever-and-ever的博客
08-23 855
为了解决非线程安全问题，就需要使用线程同步。实现线程同步的一种方式就是使用synchronized关键字。 1.synchronized的用法 （1）synchronized可以修饰方法，表示这个方法在任意时刻只能由一个线程访问。 （2）synchronized用在类声明中，表明该类中的所有方法都是synchronized的。 （3）synchronized还可以用在一段代码中，被sync...
synchronized关键字
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
10-23 224
1.Synchronized关键字概述 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而...
java 从入门到精通.zip
03-07
7.2 线程同步：学习synchronized关键字，使用wait()、notify()和notifyAll()控制线程状态。 7.3 线程池：了解ExecutorService，使用ThreadPoolExecutor创建线程池，优化多线程执行。 八、网络编程 8.1 网络编程基础...
注意：学习笔记
02-13
线程间可以通过共享变量或使用synchronized关键字进行同步。 5.2 线程状态 Java线程有新建、可运行、运行、阻塞、等待、终止六种状态。 5.3 线程池 线程池可以管理线程，避免频繁创建和销毁线程的开销，提高系统...
Midterm
03-10
4.2 异常处理结构：try-catch-finally语句块的使用，以及throws关键字的声明。 4.3 自定义异常：如何创建和抛出自定义异常。 五、集合框架 5.1 集合接口：List、Set和Queue等接口的特点及实现类，如ArrayList、...
Java语言实践教学解析.zip
10-16
6.2 线程同步：理解synchronized关键字，使用wait()、notify()和notifyAll()进行线程通信。 6.3 线程池：学习ExecutorService接口和ThreadPoolExecutor类，实现高效的线程管理。 七、网络编程 7.1 Socket通信：理解...
CPSC411-Hmwk2p2
04-15
7. **多线程**: Java支持并发编程，学生可能需要了解线程的创建、同步机制（如synchronized关键字、wait/notify机制）以及线程池。 8. **设计模式**: 在高级作业中，可能会接触到一些常见的设计模式，如单例模式、...
3.1等待/通知机制（wait/notify）
Envieol
01-18 646
wait/notify 要点 wait() 执行前 在调用wait（）之前，必须先要获得对象锁，即只有在同步方法或者同步代码块中调用wait（）方法。 执行作用 wait（）使进程进入等待（阻塞状态），在收到通知或者被中断之前都会进入预执行队列。 执行之后1 执行wait（）之后，当前线程释放改对象锁，在通知前与其他线程重新竞争资源 执行之后2 执行wait（）
3.3wait（long）
Envieol
01-18 584
使用wait（long），可以使线程超过某个时间自动唤醒，在等待的过程中也可以被notify（）唤醒
2.4String的常量池（String池）特性
Envieol
01-14 391
看一段伪代码String a = "a"; String b = "a"; String c = new String("a"); System.out.println(a==b);//true System.out.println(a==c);//false因为java的String类型会有一个常量池管理String对象，当出现的String对象在String池中不存在时即在String池中创建该
3.5生产者与消费者
Envieol
01-19 384
多生产者与多消费者-操作值：假死 假死 是所有线程都进入了waiting状态 下面是一个假死的例子 package com.myObject; public class ProducerObject { private String lock; public ProducerObject(String lock) { this.lock = lock;
synchronized 在同步代码块使用
最新发布
10-28
synchronized关键字可以用于同步代码块，以保证在同一时间只有一个线程可以访问该代码块。同步代码块需要指定一个锁对象，只有持有该锁对象的线程才能执行该代码块。当一个线程进入同步代码块时，它会尝试获取锁对象，如果锁对象已经被其他线程持有，则该线程会被阻塞，直到锁对象被释放为止。同步代码块的语法如下： ``` synchronized (锁对象) { // 需要同步的代码块 } ``` 其中，锁对象可以是任意对象，但是不同的线程必须使用同一个锁对象才能实现同步。同步代码块的作用范围只限于代码块内部，代码块外部的其他线程仍然可以访问共享资源。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值