Synchronized关键字

最新推荐文章于 2024-05-21 15:37:32 发布
最新推荐文章于 2024-05-21 15:37:32 发布
阅读量329 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swjtufq/article/details/52584001
版权

前面已经写过生产者与消费者的例子了，用到Synchronized关键字，这是java并发的一个关键点，锁机制，我不打算长篇大论，用几个概况的说明，然后每个说明加一段代码的方式来讲解：
一 当两个线程同时访问同一个Object的Synchronized方法或代码块的时候，一个时间只能一个线程执行这段代码，另外一个线程要等待前一个线程执行完这段代码才可以执行：

public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
        MyThread t2 = new MyThread(so);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(t2, "ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {
    public void synchronizedFuc() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }

}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果：
ThreadA0
ThreadA1
ThreadA2
ThreadA3
ThreadA4
ThreadA5
ThreadA6
ThreadA7
ThreadA8
ThreadA9
ThreadB0
ThreadB1
ThreadB2
ThreadB3
ThreadB4
ThreadB5
ThreadB6
ThreadB7
ThreadB8
ThreadB9
可以看到是第二个线程等第一个线程执行完相关的同步代码块才执行

二 当一个线程访问对象的Synchronized方法或者代码块的时候，另外一个线程扔可以访问该对象的非Synchronized方法，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
//      MyThread t2 = new MyThread(so);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                so.notSynchronizedFuc();
            }
        }, "ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {
    public void synchronizedFuc() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }

    public void notSynchronizedFuc() {
        for (int i = 0; i < 10; i++) {
            System.out.println("非同步代码块" + Thread.currentThread().getName() + i);
        }
    }

}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果：
ThreadA0
非同步代码块ThreadB0
ThreadA1
非同步代码块ThreadB1
ThreadA2
非同步代码块ThreadB2
ThreadA3
非同步代码块ThreadB3
ThreadA4
非同步代码块ThreadB4
ThreadA5
非同步代码块ThreadB5
ThreadA6
非同步代码块ThreadB6
ThreadA7
非同步代码块ThreadB7
ThreadA8
非同步代码块ThreadB8
ThreadA9
非同步代码块ThreadB9
可以看到相互不影响

三 当一个线程访问对象的Synchronized方法或者代码块时，其他线程想要访问该对象的其他Synchronized方法或者代码块，仍将受阻，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
//      MyThread t2 = new MyThread(so);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                so.notSynchronizedFuc();
            }
        }, "ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {
    public void synchronizedFuc() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }

    public synchronized void notSynchronizedFuc() {
        for (int i = 0; i < 10; i++) {
            System.out.println("非同步代码块" + Thread.currentThread().getName() + i);
        }
    }

}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果：
ThreadA0
ThreadA1
ThreadA2
ThreadA3
ThreadA4
ThreadA5
ThreadA6
ThreadA7
ThreadA8
ThreadA9
非同步代码块ThreadB0
非同步代码块ThreadB1
非同步代码块ThreadB2
非同步代码块ThreadB3
非同步代码块ThreadB4
非同步代码块ThreadB5
非同步代码块ThreadB6
非同步代码块ThreadB7
非同步代码块ThreadB8
非同步代码块ThreadB9

四 Synchronized控制代码块的时候，参数也可以是对象，一样可以锁定，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        MyObject my = new MyObject();
        SynchronizedObject so = new SynchronizedObject(my);
        MyThread t1 = new MyThread(so);
        MyThread t2 = new MyThread(so);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(t2,"ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {
    MyObject mo;

    public SynchronizedObject(MyObject mo) {
        this.mo = mo;
    }
    public void synchronizedFuc() {
        synchronized (mo) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }


}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

class MyObject {
    public MyObject() {

    }
}

执行结果：
ThreadA0
ThreadA1
ThreadA2
ThreadA3
ThreadA4
ThreadA5
ThreadA6
ThreadA7
ThreadA8
ThreadA9
ThreadB0
ThreadB1
ThreadB2
ThreadB3
ThreadB4
ThreadB5
ThreadB6
ThreadB7
ThreadB8
ThreadB9
可以看到，一样锁定了

五 以上情况必须是针对线程访问同一个对象，如果是不同对象呢，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        SynchronizedObject so1 = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
        MyThread t2 = new MyThread(so1);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(t2,"ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {

    public void synchronizedFuc() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }


}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果如下：
ThreadA0
ThreadB0
ThreadA1
ThreadB1
ThreadA2
ThreadB2
ThreadA3
ThreadB3
ThreadA4
ThreadB4
ThreadA5
ThreadB5
ThreadA6
ThreadB6
ThreadA7
ThreadB7
ThreadA8
ThreadB8
ThreadA9
ThreadB9
发现没有同步。

六 如果把synchronizedFuc方法改成static的，就不是锁住对象了，而是锁住类，即使是两个对象，也可以达到同步的效果，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        SynchronizedObject so1 = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
        MyThread t2 = new MyThread(so1);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(t2,"ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {

    public synchronized static void synchronizedFuc() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }

    }


}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果如下：
ThreadA0
ThreadA1
ThreadA2
ThreadA3
ThreadA4
ThreadA5
ThreadA6
ThreadA7
ThreadA8
ThreadA9
ThreadB0
ThreadB1
ThreadB2
ThreadB3
ThreadB4
ThreadB5
ThreadB6
ThreadB7
ThreadB8
ThreadB9

七 如果想锁住类，可以直接Synchronized(X.class)，如下：


public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedObject so = new SynchronizedObject();
        SynchronizedObject so1 = new SynchronizedObject();
        MyThread t1 = new MyThread(so);
        MyThread t2 = new MyThread(so1);
        Thread ta = new Thread(t1, "ThreadA");
        Thread tb = new Thread(t2, "ThreadB");
        ta.start();
        tb.start();

    }
}

class SynchronizedObject {

    public void synchronizedFuc() {
        synchronized (SynchronizedObject.class) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }

}

class MyThread implements Runnable {
    SynchronizedObject so = null;

    public MyThread(SynchronizedObject so) {
        this.so = so;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        if (so != null) {
            so.synchronizedFuc();
        }
    }

}

执行结果如下：
ThreadA0
ThreadA1
ThreadA2
ThreadA3
ThreadA4
ThreadA5
ThreadA6
ThreadA7
ThreadA8
ThreadA9
ThreadB0
ThreadB1
ThreadB2
ThreadB3
ThreadB4
ThreadB5
ThreadB6
ThreadB7
ThreadB8
ThreadB9
达到同步效果了

总结：
1 当两个线程同时访问同一个Object的Synchronized方法或代码块的时候，一个时间只能一个线程执行这段代码，另外一个线程要等待前一个线程执行完这段代码才可以执行。
2 当一个线程访问对象的Synchronized方法或者代码块的时候，另外一个线程扔可以访问该对象的非Synchronized方法。
3 当一个线程访问对象的Synchronized方法或者代码块时，其他线程想要访问该对象的其他Synchronized方法或者代码块，仍将受阻。
4 Synchronized控制代码块的时候，参数也可以是对象，一样可以锁定。
5 当线程访问不同对象时，用Synchronized修饰方法或者Synchronized（this），不能锁定。
6 如果把synchronizedFuc方法改成static的，就不是锁住对象了，而是锁住类，即使是两个对象，也可以达到同步的效果。
7 如果想锁住类，可以直接Synchronized(X.class)。
如有问题，欢迎指正，谢谢

swjtufq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized关键字
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
10-23 231
1.Synchronized关键字概述 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而...
Synchronized关键字详解
qq_37134175的博客
07-30 263
一、Synchronized关键字 synchronized 内置锁是一种对象锁，作用粒度是对象而非引用变量，可将任何非空对象当做“锁”，可用来修饰方法或代码块以保证同一时刻最多只有一个线程执行被修饰方法或代码块。synchronized 修饰的地方不相同，但它的锁都在一个对象上，它持有相同对象锁的地方发产生互斥，而不是只有当前所指的代码块或者方法体。 相对于显示锁，synchroniz...
synchronized关键字的使用
最新发布
qq_44286009的博客
05-21 403
synchronized 是 Java 中的一个关键字，用于实现多线程之间的同步访问。它用于确保在多线程环境中，同一时间只有一个线程可以执行某个方法或代码块。这是通过锁定一个对象或类来实现的，以防止多个线程同时访问共享资源，从而导致数据不一致或其他并发问题。在方法声明中使用synchronized，将其放在范围操作符（如public）后，返回类型声明（如void）之前。这样，当一个线程进入该方法时，其他线程将被阻塞，直到该线程退出该方法。例如：// 方法体。
synchronized关键字详解
LYQ20010417的博客
04-13 4520
内容包括：synchronized的锁类型、实际应用、实现原理、锁升级过程和锁优化等
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
synchronized 关键字详解
TanaStudy的博客
04-07 7040
synchronized 关键字1. synchronized 关键字的三种使用方法1.1. 修饰实例方法2.2. 修饰静态方法3.3. 修饰代码块2. 双重检验锁方式实现单例模式3. 构造方法可以使用 synchronized 关键字修饰么？4. JDK1.6 之后的 synchronized 关键字底层做了哪些优化？5. synchronized 和 ReentrantLock 的区别6. synchronized 关键字与Lock的区别 synchronized 关键字解决的是多个线程之间访问资源的同
Java synchronized关键字使用方式及特性解析
08-25
需要注意的是，synchronized关键字的使用需要遵守一定的原则，例如避免使用synchronized关键字在循环语句中，以免出现死锁等问题。此外，synchronized关键字也可以与其他线程同步工具结合使用，以实现更复杂的线程...
Lock接口与synchronized关键字
04-19
### Lock接口与synchronized关键字详解 #### 一、概述 在Java并发编程中，Lock接口与synchronized关键字都是实现同步的重要工具。它们虽然都用于控制多线程对共享资源的访问，但在使用方式、功能特性及灵活性方面...
java Lock和Condition的用法
swjtufq的博客
09-19 8496
前面我分享了Synchronized的使用，当一个线程访问一个对象的Synchronized方法或者代码块的时候，就持有了锁，除非执行完或者遇到异常（发生异常JVM虚拟机会自动释放锁），才能释放锁，但是如果在执行代码块里sleep了或者有一些耗时很久的操作，那么锁就一直不释放，其他线程就会一直等待下去，Lock可以不让其他线程一直无限等待下去，另外一种情况，当有多个线程读写文件的时候，读和写会发生冲
Executor和线程池之我的理解
swjtufq的博客
09-18 465
以前写线程，一般new一个Thread或者实现Runnable接口，jdk1.5之后引入了Executor框架，这个框架可以易于我们对线程的管理，复用线程，节约开销等等，Executor有一个很重要的子类，ExecutorService，也是一个接口，这才是我们经常要用的类，线程池ThreadPoolExecutor的父类实现了ExecutorService这个接口，常用的四个线程池，newCach
String,StringBuffer和StringBuilder之我的理解
swjtufq的博客
09-12 440
String和StringBuffer都是JDK 1.0提出来的，StringBuilder是JDK 1.5才有的，StringBuffer和StringBuilder都继承AbstractStringBuilder，下面分别对这三个类的效率进行描述 1 String是不可变对象，对String对象的改变分几种情况Sting s = "a" + "b";这种情况等价于 String s = "ab
设计模式-责任链模式
swjtufq的博客
11-17 330
说到责任链模式，几年前有一次面试经历，面试官拿着两页程序来考我设计模式，其实就是责任链模式，今天就来总结下这个模式 其实责任链模式的好处就是让我们省略了很多if/else或者switch语句，多个对象都有机会处理，从而避免了请求的发送者和接受者之间的耦合，形成一个链，沿着这个链传递，知道有一个对象处理为止。 角色： 1 抽象处理者（Handler）角色，定义一个处理请求的接口，定义两个方法，分
java volatile关键字
swjtufq的博客
09-20 328
这个关键字平时用的比较少，但是在面试的时候经常被问到，解释不清楚又比较尴尬，所以今天来聊一聊，java内存模型中所有的变量都是存放在内存中的，线程有自己的工作内存（类似于高速缓存），线程对变量的操作都是在工作内存中进行，不同的线程不能访问其他的线程的工作内存，画个图来表示下： 也就是说内存中的一个变量，每个线程类似于保存了该变量的一个副本，线程对该变量的修改会先保存到工作内存中，然后再同步到内
生产者与消费者问题
swjtufq的博客
09-18 307
最近在看java并发编程，生产者与消费者是个经典题目，5年前去百度面试的时候，让我当场写出这个程序，今天我就回顾一下，这里涉及到几个点，一个生产者，一个消费者，一个馒头实体类，一个馒头筐类，一个main方法类，记住这几个点，生产者和消费者程序就很好写了，代码如下:/* * 生产者与消费者问题 */ public class ProduceConsume { public static v
设计模式-观察者模式
swjtufq的博客
11-16 236
观察者模式中主要有4中角色： 1 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）中，每个主题都可以有任意数量的观察者，抽象主题里提供接口，增加和删除观察者，通知观察者。 2 具体主题(ConcreteSubject)角色：将有关状态，存入具体的观察者对象，当自己状态发生改变时，通知所有的观察者 3 抽象观察者（Observer）
设计模式-策略模式
swjtufq的博客
11-17 231
在软件开发中，我们经常遇到针对不同情况使用不同的算法或者逻辑，然后用if/else来控制起来，我们来看个例子，比如说国足要征战世界杯亚洲区12强赛，那么针对不同对手，需要有不同的打法和战术public void test(String duishou){ if(duishou.equals("韩国")){ System.out.println("执行防守反击战
设计模式-单例模式
swjtufq的博客
11-11 225
相信大家去面试的时候，经常被问到单例模式的有关问题吧，今天我们就来好好总结一下 一 懒汉式public class Singleton { private static Singleton instance = null; private Singleton() {} public static Singleton getInstance() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值