Java锁之Synchronized的简单使用

最新推荐文章于 2023-09-01 15:11:38 发布
最新推荐文章于 2023-09-01 15:11:38 发布
阅读量72 收藏
点赞数
分类专栏： java 文章标签： synchronized java 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiasunan/article/details/112062066
版权

方法区和堆区的代码是多个线程共享的，多个线程同时操作方法区或堆区的共享代码时就会存在线程安全问题。

那怎么解决线程安全问题？

使用synchronized给共享资源加锁就是其中的一种解决方法。

简单使用

下面的代码中SynchronizedTest类的静态成员变量num存储在内存中的方法区，当被多线程同时操作时是线程不安全的

class SynchronizedTest {

    private static int num = 0;

    static class AThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    //休眠100毫秒来模拟实际开发情况
                    Thread.sleep(100);
                    num ++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class BThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                    num ++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

        //创建线程并启动线程执行任务
        Thread aThread = new Thread(new SynchronizedTest.AThread());
        Thread bThread = new Thread(new SynchronizedTest.BThread());
        aThread.start();
        bThread.start();

        //main线程等待aThread和bThread线程执行完毕
        aThread.join();
        bThread.join();

        System.out.println(num); //小于20，存在线程安全问题
        
    }
}

通过synchronized加锁解决线程安全问题

class SynchronizedTest {

    private static int num = 0;

    static class AThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    synchronized (SynchronizedTest.class){
                        Thread.sleep(100);
                        num ++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class BThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    synchronized (SynchronizedTest.class){
                        Thread.sleep(100);
                        num ++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

        //创建线程并启动线程执行任务
        Thread aThread = new Thread(new AThread());
        Thread bThread = new Thread(new BThread());
        aThread.start();
        bThread.start();

        //main线程等待aThread和bThread线程执行完毕
        aThread.join();
        bThread.join();

        System.out.println(num); //等于20，不存在线程安全问题
    }
}
锁的粒度
锁住当前对象

synchronized加在对象方法上或synchronized (this)代码块，锁的粒度都是当前对象，对象之间不互斥，当类的多个对象并发调用此方法，存在线程安全问题

class SynchronizedObject {

    public static int num = 0;

    //锁定的是对象
    public synchronized void increNum1(){
        try {
            Thread.sleep(100);
            num ++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void increNum2(){
        //锁定的是对象
        synchronized (this){
            try {
                Thread.sleep(100);
                num ++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class SynchronizedObjectTest1 {

    static class AThread implements Runnable {
    	
        private SynchronizedObject synchronizedObject = new SynchronizedObject();

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedObject.increNum1();
                synchronizedObject.increNum2();
            }
        }
    }

    static class BThread implements Runnable {

        private SynchronizedObject synchronizedObject = new SynchronizedObject();

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedObject.increNum1();
                synchronizedObject.increNum2();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
		
        Thread aThread = new Thread(new AThread());
        Thread bThread = new Thread(new BThread());
        aThread.start();
        bThread.start();

        aThread.join();
        bThread.join();

        System.out.println(SynchronizedObject.num); //小于20，线程不安全
    }
}

class SynchronizedObjectTest2 {

    static class AThread implements Runnable {

        private SynchronizedObject synchronizedObject;

        public AThread(SynchronizedObject synchronizedObject) {
            this.synchronizedObject = synchronizedObject;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedObject.increNum1();
                synchronizedObject.increNum2();
            }
        }
    }

    static class BThread implements Runnable {

        private SynchronizedObject synchronizedObject;

        public BThread(SynchronizedObject synchronizedObject) {
            this.synchronizedObject = synchronizedObject;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedObject.increNum1();
                synchronizedObject.increNum2();
            }
        }
    }

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

        SynchronizedObject synchronizedObject = new SynchronizedObject();

        Thread aThread = new Thread(new AThread(synchronizedObject));
        Thread bThread = new Thread(new BThread(synchronizedObject));
        aThread.start();
        bThread.start();

        aThread.join();
        bThread.join();

        System.out.println(SynchronizedObject.num); //输出20，线程安全
    }
}
锁住类的全部对象

synchronized加在类方法上或synchronized (SynchronizedClass.class)代码块，锁住类的全部对象，对象之间互斥，当类多个对象并发调用此方法，需要排队，不存在线程安全问题

class SynchronizedClass {

    public static int num = 0;

    public static void increNum1(){
        try {
            Thread.sleep(100);
            num ++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void increNum2(){
        synchronized (SynchronizedClass.class){
            try {
                Thread.sleep(100);
                num ++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class SynchronizedClassTest1 {

    static class AThread implements Runnable {

        private SynchronizedClass synchronizedClass = new SynchronizedClass();

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedClass.increNum1();
                synchronizedClass.increNum2();
            }
        }
    }

    static class BThread implements Runnable {

        private SynchronizedClass synchronizedClass = new SynchronizedClass();

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedClass.increNum1();
                synchronizedClass.increNum2();
            }
        }
    }

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

        Thread aThread = new Thread(new AThread());
        Thread bThread = new Thread(new BThread());
        aThread.start();
        bThread.start();

        aThread.join();
        bThread.join();

        System.out.println(SynchronizedClass.num); //输出20，线程安全
    }
}

class SynchronizedClassTest2 {

    static class AThread implements Runnable {

        private SynchronizedClass synchronizedClass;

        public AThread(SynchronizedClass synchronizedClass) {
            this.synchronizedClass = synchronizedClass;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedClass.increNum1();
                synchronizedClass.increNum2();
            }
        }
    }

    static class BThread implements Runnable {

        private SynchronizedClass synchronizedClass;

        public BThread(SynchronizedClass synchronizedClass) {
            this.synchronizedClass = synchronizedClass;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                //synchronizedClass.increNum1();
                synchronizedClass.increNum2();
            }
        }
    }

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

        SynchronizedClass synchronizedClass = new SynchronizedClass();

        Thread aThread = new Thread(new AThread(synchronizedClass));
        Thread bThread = new Thread(new BThread(synchronizedClass));
        aThread.start();
        bThread.start();

        aThread.join();
        bThread.join();

        System.out.println(SynchronizedClass.num); //输出20，线程安全
    }
}
wait、notify和notifyAll
Object.wait()使当前的线程进入到等待状态（进入到等待队列）
Object.notifyAll() 唤醒等待中的全部线程
Object.notify() 随机唤醒一个线程

使用wait和notifyAll实现生产者消费者模式

/*
 * 生产者
 */
class Producer extends Thread {

    private List<String> container;
    private int count = 1;

    public Producer(String name, List<String> container) {
        super(name);
        this.container = container;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (container) {
                if (container.size() == 10){
                    try {
                        //满了，不再生产，进入等待状态
                        container.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else {
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("生产: 苹果"+count);
                    container.add(new String("苹果"+count));
                    count ++;
                    container.notifyAll();
                }
            }
        }
    }
}

/*
 * 消费者
 */
class Consumer extends Thread {

    private List<String> container;

    public Consumer(String name, List<String> container) {
        super(name);
        this.container = container;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (container) {
                if (container.isEmpty()){
                    try {
                        //没有产品可消费，进入等待状态
                        container.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else {
                    try {
                        sleep(1500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String str = container.get(0);
                    container.remove(0);
                    System.out.println("消费: "+str);
                    container.notifyAll();
                }
            }
        }
    }
}

class Test {
    public static void main(String[] args) {
        List<String> container = new ArrayList<>();
        new Producer("富士康", container).start();
        new Consumer("专卖店", container).start();
    }
}
sunanjia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程创建之重要属性PTHREAD_CREATE_DETACHED
Vinco's special column
04-15 1万+
#include int pthread_join(pthread_t thread, void **value_ptr); int pthread_detach(pthread_t thread); int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); int pthread_attr_set
ubuntu线程的属性PTHREAD_CREATE_JOINABL和PTHREAD_CREATE_DETACHED
fengjunwang1980的专栏
06-30 3579
ubuntu系统线程属性设置，joinable和detached
JavaGuide面试突击最新版
10-01
JavaGuide面试突击最新版
【Java并发编程】Java多线程（五）：关于线程的几个问题
A minor
09-16 1595
1.子线程 1 去等待子线程 2 执行完成之后才能执行，如何去实现？ 答：这里考察的就是 Thread.join 方法，我们可以这么做： @Test public void testJoin2() throws Exception { // 线程2 Thread thread2 = new Thread(new Runnable() { public void run() {...} }); // 线程1 Thread thread1 = new Thread(new Runna
线程分离pthread_detach、pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
inuyashaw的博客
12-26 4837
http://blog.csdn.net/seucbh84/article/details/12649267###; linux线程执行和windows不同，pthread有两种状态joinable状态和unjoinable状态， 如果线程是joinable状态，当线程函数自己返回退出时或pthread_exit时都不会释放线程所占用堆栈和线程描述符（总计8K多）。只有当你调用了pthre
【彻底弄懂】linux中pthread_detach()的作用
Clear Code
11-20 1万+
文章目录linux中pthread_detach()解析 linux中pthread_detach()解析 使用pthread_create创建的线程有两种状态：joinable和unjoinable。默认是joinable 状态，可以通过这个api 来获取其状态 pthread_attr_getdetachstate另外可以通过如下代码来设置为状态joinable 还是 unjoinable pthread_attr_t attr; pthread_attr_init(&attr); pthrea
Java使用synchronized实现互斥锁功能示例
08-19
主要介绍了Java使用synchronized实现互斥锁功能,结合实例形式分析了Java使用synchronized互斥锁功能简单实现方法与操作技巧,需要的朋友可以参考下
Java中synchronized关键字引出的多种锁 问题
08-25
synchronized关键字是JAVA中常用的同步功能，提供了简单易用的锁功能。这篇文章主要介绍了Java中synchronized关键字引出的多种锁问题,需要的朋友可以参考下
Lock接口与synchronized关键字
最新发布
04-19
首先，从使用方式上来看，synchronized是Java语言内置的关键字，它可以修饰方法或代码块，使用起来相对简单直观。当线程进入synchronized修饰的方法或代码块时，会自动获取锁，并在退出时自动释放锁。而Lock接口则是...
Java并发编程实战 03互斥锁 解决原子性问题
01-20
文章系列 Java并发编程实战 01并发编程的Bug源头 Java并发编程实战 02Java如何解决可见性和有序性问题 ...简易锁 我们把一段需要互斥执行的代码称为临界区，线程进入临界区之前，首先尝试获取加锁，若加
死锁_Java产生死锁的简单案例
12-22
某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。 主要点： 过多的同步可能造成相互不释放资源。 从而互相等待，一般发生于同步中持有多个对象的锁。 解决：不要在同一个代码块中，同时...
多线程
coffee0218的博客
06-07 260
进程是包含程序指令和相关资源的集合，每个进程和其他进程一起参与调度，竞争CPU、内存等系统资源。每次进程切换，都存在进程资源的保存和恢复动作，这称为上下文切换。进程的引入可以解决多用户支持的问题，但是多进程系统也在如下方面产生了新的问题：进程频繁切换引起的额外开销可能会严重影响系统性能。进程间通信要求复杂的系统级实现。 同一个进程内部的多个线程，共享的是同一个进程的所有资源。比如，与每个进程独有...
Linux pthread_create 如何设置 线程的detach 状态
千里之行,始于足下
06-12 1734
Linux pthread_create 如何设置 线程的detach 状态Ted posted @ 2008年9月04日 21:40 in system programming with tags thread , 1068 阅读 <br />1 引言<br />线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的 Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，
pthread_create()使用detach分离后仍有内存泄漏
qq_27898413的博客
09-01 292
线程的取消类型由pthread setcanceltype(3)决定，可以是异步的，也可以是延迟的(新线程的默认值)。3.上面的内存之所以没有释放，可能是因为线程并未结束进程就直接退出了(这一点不确定，有知道的大佬可以在评论区留下宝贵意见)，例如上面的例子，虽然使用pthread_cancel取消了线程，但是pthread_cancel只是发出取消请求，线程可以在任何时候被取消。在被取消的线程终止后，使用pthread_join(3)与该线程的连接将获得PTHREAD_CANCELED作为线程的退出状态。
正确使用pthread_create，防止内存泄漏
David_xtd的专栏
11-20 1万+
近日，听说pthread_create会造成内存泄漏，觉得不可思议，因此对posix(nptl)的线程创建和销毁进行了分析。 分析结果：如果使用不当，确实会造成内存泄漏。 产生根源：pthread_create默认创建的线程是非detached的。 预防方式：要么创建detached的线程，要么线程线程的start_routine结束之前detached，要么join
Java线程安全与不安全
热门推荐
CodeHunter_qcy
06-05 1万+
Java非线程安全与线程安全 ArrayList和Vector的区别在哪里？ HashMap和HashTable区别在哪里？ StringBuilder和StringBuffer区别在哪里？ 张口即答，区别在于前者是非线程安全的，后者是线程是线程安全的。 那么，到底什么叫线程安全？什么叫线程不安全？线程安全不安全的原因是什么？怎么实现线程安全？线程安全和非线程安全有什么区别？分别在什么情况下使用？...
【Linux】连接已终止的线程（pthread_join）、线程的分离（pthread_detach）、线程取消（pthread_detach）
mhyasadj的博客
05-30 602
连接已终止的线程（pthread_join）、线程的分离（pthread_detach）、线程取消（pthread_detach）
2023年全网最新版Java面试突击手册PDF版开源，押题率高达97%
m0_73311735的博客
06-05 212
作为Java程序员，选择学习什么样的技术？什么技术该不该学？去招聘网站上搜一搜、看看岗位要求就十分清楚了，自己具备的技术和能力，直接影响到你工作选择范围和能不能面试成功。如果想进大厂，那就需要在Java核心技术栈上面好好准备了，具体可以分下面几个模块来学习。学习模块常见模式与工具：学习Java技术体系，设计模式，流行的框架与组件—— 常见的设计模式，编码必备， Spring5，做应用必不可少的最新框架，MyBatis，玩数据库必不可少的组件。从源码级别掌握它们，你比别人更容易进大厂。
java锁synchronized与lock
06-28
Java中的锁机制有两种：...总的来说，synchronized是Java中最常用的锁机制，它简单易用，但是功能相对较少；而Lock锁机制则更加灵活，但是使用起来相对复杂一些。在实际开发中，应该根据具体的需求选择合适的锁机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值