Java并发编程学习（二）—— 对象及变量的并发访问

最新推荐文章于 2022-03-14 20:10:15 发布
最新推荐文章于 2022-03-14 20:10:15 发布
阅读量183 收藏
点赞数
分类专栏： 读书笔记 文章标签： java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amurocrash/article/details/78751076
版权

一、synchronized

1、synchronized取得的都是对象锁，而不是把一段代码或方法当做锁。

package com.amuro.studythread.chapter_2_concurrent_access;

public class SynchronizedBase
{
    public static void main(String[] args)
    {
        SynchronizedObject obj = new SynchronizedObject();
        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                obj.test1();
            }
        });
        t1.setName("t1");
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                obj.test2();
            }
        });
        t2.setName("t2");
        t2.start();
    }

    private static class SynchronizedObject
    {
        synchronized void test1()
        {
            System.out.println("test1 begin with thread " + Thread.currentThread().getName());
            try
            {
                Thread.sleep(5000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("test1 end with thread " + Thread.currentThread().getName());
        }

        synchronized void test2()
        {
            System.out.println("test2 begin with thread " + Thread.currentThread().getName());
            try
            {
                Thread.sleep(1000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("test2 end with thread " + Thread.currentThread().getName());
        }
    }
}

这个例子中，虽然两个线程访问的是同一个对象不同的方法，但因为两个方法都加了对象锁，所以必须等到先拿到锁的那个线程执行完成释放锁后，才能执行自己的方法。

2、脏读

package com.amuro.studythread.chapter_2_concurrent_access;

public class DirtyRead
{
    public static void main(String[] args)
    {
        SynchronizedObject obj = new SynchronizedObject();
        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                obj.set("b", "bb");
            }
        });
        t1.start();

        try
        {
            Thread.sleep(1000);
        } 
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                System.out.println(obj.getPassword());
            }
        });
        t2.start();
    }

    private static class SynchronizedObject
    {
        private String username = "a";
        private String password = "aa";

        synchronized void set(String username, String password)
        {
            this.username = username;
            try
            {
                Thread.sleep(5000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.password = password;
        }

        public String getPassword()
        {
            return password;
        }
    }
}

打印结果是aa，也就是说线程1还没有来得及修改好所有变量的值，线程2已经去获取值了，赋值同步而取值不同步导致的数据错误就叫脏读，该实例的解决方法就是在getPassword方法前也加上synchronized关键字。

3、可重入锁：自己可以再次获取自己的内部锁。比如某个线程获得了某个对象的锁，此时这个对象锁还没有释放，当它再次要获得这个对象的锁时还是可以获取的。简单来说：

synchronized test1()
{
    System.out.println("1");
    test2();
}

synchronized test2()
{
    System.out.printlin("2");
}

如果线程1拿到了对象锁，那方法1是可以顺利调用方法2的。所以synchronized是可重入锁。
PS：可重入锁同时适用于父类和子类。

4、当一个线程执行的代码出现异常（未捕获）时，其所持有的锁会自动释放。

5、synchronized没有继承性。

6、synchronized(this) 用同步代码块解决同步方法的弊端。

package com.amuro.studythread.chapter_2_concurrent_access;

public class SynchronizedCompare
{
    public static void main(String[] args)
    {
        SyncMethod.invoke();
        SyncThis.invoke();
    }

    private static class SyncMethod
    {   
        private static long begin = 0;
        private static long end = 0;

        private static void invoke()
        {
            SyncMethod sm = new SyncMethod();
            Thread t1 = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    begin = System.currentTimeMillis();
                    sm.test();
                }
            });
            t1.start();

            try
            {
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            Thread t2 = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    sm.test();
                    end = System.currentTimeMillis();
                    System.out.println("SyncMethod use time " + (end - begin));
                }
            });
            t2.start();
        }

        int i = 0;

        synchronized void test()
        {
            try
            {
                Thread.sleep(3000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            i++;

        }

    }

    private static class SyncThis
    {
        private static long begin = 0;
        private static long end = 0;

        private static void invoke()
        {
            SyncThis sm = new SyncThis();
            Thread t1 = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    begin = System.currentTimeMillis();
                    sm.test();
                }
            });
            t1.start();

            try
            {
                Thread.sleep(100);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            Thread t2 = new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    sm.test();
                    end = System.currentTimeMillis();
                    System.out.println("SyncThis use time " + (end - begin));
                }
            });
            t2.start();
        }

        int i = 0;

        void test()
        {
            try
            {
                Thread.sleep(3000);
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            synchronized (this)
            {
                i++;
            }

        }

    }


}

程序输出：
SyncThis use time 3104
SyncMethod use time 6007
假设我们只需要保证对i操作的线程安全，那用syncMethod的时间消耗就比Sync块的消耗要大一倍，原因就是syncMethod是很蛮横的把类中所有加了synchronized的方法都锁了起来。

7、synchronized（anyObject）
一个类中如果有多个synchronized方法，当一个方法阻塞时会导致该类中所有的同步方法都阻塞，所以使用非this锁可以大大提高效率。

8、synchronized(anyObject)解决synchronized方法的脏读问题

package com.amuro.studythread.chapter_2_concurrent_access;

import java.util.ArrayList;
import java.util.List;

public class DirtyReadPro
{
    public static void main(String[] args) throws Exception
    {
        MyOneList list = new MyOneList();
        MyThread1 t1 = new MyThread1(list);
        t1.setName("t1");
        t1.start();
        MyThread2 t2 = new MyThread2(list);
        t2.setName("t2");
        t2.start();
        Thread.sleep(6000);
        System.out.println(list.getSize());
    }

    private static class MyOneList
    {
        List<String> list = new ArrayList<>();
        synchronized void add(String data)
        {
            System.out.println(Thread.currentThread() + " add data");
            list.add(data);
        }

        synchronized int getSize()
        {
            System.out.println(Thread.currentThread() + " get Size");
            return list.size();
        }
    }

    private static class Service
    {
        MyOneList addServiceMethod(MyOneList list, String data)
        {
            try
            {
                if(list.getSize() < 1)
                {
                    Thread.sleep(2000);
                    list.add(data);
                }
            }
            catch(Exception e)
            {

            }

            return list;
        }
    }

    public static class MyThread1 extends Thread
    {
        MyOneList list;

        public MyThread1(MyOneList list)
        {
            super();
            this.list = list;
        }

        @Override
        public void run()
        {
            Service service = new Service();
            service.addServiceMethod(list, "A");
        }
    }

    public static class MyThread2 extends Thread
    {
        MyOneList list;

        public MyThread2(MyOneList list)
        {
            super();
            this.list = list;
        }

        @Override
        public void run()
        {
            Service service = new Service();
            service.addServiceMethod(list, "B");
        }
    }


}

程序输出：
Thread[t1,5,main] get Size
Thread[t2,5,main] get Size
Thread[t1,5,main] add data
Thread[t2,5,main] add data
Thread[main,5,main] get Size
2
原因很简单，线程1调用getSize方法后sleep，此时MyOneList的锁已经释放，所以线程2调用getSize方法时直接可以进入，并且此时1的add方法还没来得及执行，导致1和2都可以执行add方法。
修正：

package com.amuro.studythread.chapter_2_concurrent_access;

import java.util.ArrayList;
import java.util.List;

public class DirtyReadProFix
{
    public static void main(String[] args) throws Exception
    {
        MyOneList list = new MyOneList();
        MyThread1 t1 = new MyThread1(list);
        t1.setName("t1");
        t1.start();
        MyThread2 t2 = new MyThread2(list);
        t2.setName("t2");
        t2.start();
        Thread.sleep(6000);
        System.out.println(list.getSize());
    }

    private static class MyOneList
    {
        List<String> list = new ArrayList<>();
        void add(String data)
        {
            System.out.println(Thread.currentThread() + " add data");
            list.add(data);
        }

        int getSize()
        {
            System.out.println(Thread.currentThread() + " get Size");
            return list.size();
        }
    }

    private static class Service
    {
        MyOneList addServiceMethod(MyOneList list, String data)
        {
            try
            {
                synchronized (list)
                {
                    if(list.getSize() < 1)
                    {
                        Thread.sleep(2000);
                        list.add(data);
                    }
                }

            }
            catch(Exception e)
            {

            }

            return list;
        }
    }

    public static class MyThread1 extends Thread
    {
        MyOneList list;

        public MyThread1(MyOneList list)
        {
            super();
            this.list = list;
        }

        @Override
        public void run()
        {
            Service service = new Service();
            service.addServiceMethod(list, "A");
        }
    }

    public static class MyThread2 extends Thread
    {
        MyOneList list;

        public MyThread2(MyOneList list)
        {
            super();
            this.list = list;
        }

        @Override
        public void run()
        {
            Service service = new Service();
            service.addServiceMethod(list, "B");
        }
    }
}

当把list作为锁时，因为线程1，2操作的都是同一个list对象，所以在线程1执行完add操作前，线程2无法进入。这样就能解决脏读的问题了。

9、synchronized方法用于静态方法时，锁的是当前类的class，所以对当前类的所有实例都有效，因为class是唯一的嘛~

10、常量池特性的类的坑

String a = "A";
String b = "A";

当用a和b做锁的时候，本质是一把锁，因为a == b。

11、经典死锁

package com.amuro.studythread.chapter_2_concurrent_access;

public class DeadLock1
{
    public static void main(String[] args) throws Exception
    {
        DeadLockRunnable runnable = new DeadLockRunnable();
        Thread t1 = new Thread(runnable);
        t1.setName("t1");
        t1.start();

        Thread.sleep(100);

        Thread t2 = new Thread(runnable);
        t2.setName("t2");
        t2.start();
    }

    private static class DeadLockRunnable implements Runnable
    {
        private Object lock1 = new Object();
        private Object lock2 = new Object();

        @Override
        public void run()
        {
            try
            {
                if(Thread.currentThread().getName().equals("t1"))
                {
                    synchronized (lock1)
                    {
                        System.out.println("t1 acquire lock1");

                        Thread.sleep(1000);

                        System.out.println("t1 try to acquire lock2");
                        synchronized (lock2)
                        {
                            System.out.println("t1 end");
                        }
                    }
                }
                else
                {
                    synchronized (lock2)
                    {
                        System.out.println("t2 acquire lock2");
                        Thread.sleep(1000);

                        System.out.println("t2 try to acquire lock1");
                        synchronized (lock1)
                        {
                            System.out.println("t2 end");
                        }

                    }
                }
            }
            catch(Exception e)
            {

            }

        }
    }
}

程序输出：
t1 acquire lock1
t2 acquire lock2
t1 try to acquire lock2
t2 try to acquire lock1
程序永远无法执行完成。线程1拿到锁1后，在等待时锁2已经被线程2获取，当等待结束时线程1尝试再去获取锁2就会阻塞除非锁2被释放，而线程2在等待后又去尝试目前被线程1占用的锁1，两个线程永远也无法获得对方持有的锁，于是就进入了死锁。

12、只要对象不变，修改对象的属性对锁没有影响，也就是说对synchronized来说，仍然是一把锁。

二、volatile

1、JVM被设置成-server模式时为了提升线程运行效率，线程会一直在私有堆栈中取得私有变量的值，此时调用该变量的set方法时，设置的却是该变量在公用堆栈中的值，从而导致设置失败。这个时候就要使用volatile关键字，它的主要作用就是让线程访问该私有变量时，强制从公共堆栈中取值。
不使用：
这里写图片描述

使用后：
这里写图片描述

（怎么感觉像减肥药广告……）

2、volatile提供变量多线程间的可见性，但不具备原子性。

3、实现i++操作时的线程安全，除了使用synchronized，也可以使用原子类(AtomicInteger)。底层都是使用了Java的Unsafe类，这个类可以把C能做Java不能做的事都做了，后面有机会专门写一篇聊聊。

4、synchronized可以同时保证原子性和可见性，它不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进入同步方法或同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。

amurocrash
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7446
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java并发编程学习——对象的组合
setail的专栏
09-20 1665
对象的组合主要介绍一些组合模式，使得一个类更容易成为线程安全的类，在维护这些类时不会无意中破坏类的安全性保证。1.设计线程安全的类设计线程安全类的过程中，需要包含以下三个基本要素： 找出构成对象状态的所有变量； 找出约束状态变量的不变性条件； 建立对象状态的并发访问管理策略。 对象的状态 如果所有的域都是基本类型，则这些域构成对象的全部状态； 如果包含其他对象，该对象的状态将包括被引用对象的域。
多线程编程：对象及变量的并发访问
weixin_43237071的博客
01-18 1344
多线程编程：对象及变量的并发访问： volatile 关键字 synchronized 同步方法 synchronized同步语句块 volatile 关键字： 关键字volatile的主要作用是使变量在多个线程间可见 。 如果不在多继承的情况下， 使用继承Thread类 和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现多继承的情况，则实现Runnable接口...
JAVA多线程-对象及变量的并发访问（一）synchronized详解
绝版灬小伙的博客
02-20 4354
一、synchronized同步方法 1.1 方法内的变量为线程安全     非线程安全的问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程安全”问题，所得结果也就是“线程安全”的了。 1.2 实例变量非线程安全     如果多个线程共同访问1个对象中的实例变量，则有可能出现“非线程安全”问题。 1.3 多个对象多个锁     synchronized关
Java并发编程之美——第二章 并发编程的其他知识
Hireek的博客
12-27 662
文章目录Time 2021-12-27——Hireek什么是多线程并发编程为什么要并发Java中的线程安全什么是线程安全原子性可见性有序性synchronizedvolatileCAS（Comp are-and-Swap） 并发处理的广泛应用是Amdahl定律代替摩尔定律成为计算机性能发展源动力的根本原因，也是人类压榨计算机运算能力的最有力武器。 Time 2021-12-27——Hireek 什么是多线程并发编程 首先要澄清并发和并行的概念，并发是指同一个时间段内多个任务同时都在执行，并且都没有执行结
Java并发编程面经大全——双非上岸阿里巴巴系列
weixin_43899069的博客
06-17 3165
双非本科，四面成功上岸阿里巴巴，在这里把自己整理的面经分享出来，欢迎大家阅读。 序号 文章名 超链接 1 操作系统面经大全——双非上岸阿里巴巴系列 2021最新版面经——>传送门1 2 计算机网络面经大全——双非上岸阿里巴巴系列 2021最新版面经——>传送门2 3 Java并发编程面经大全——双非上岸阿里巴巴系列 2021最新版面经——>传送门3 4 面试阿里，你必须知道的背景知识——双非上岸阿里巴巴系列 2021最新版面经——>传送门4 如有疏漏
Java并发编程之美——第六章 Java并发包中锁原理剖析
Hireek的博客
01-01 2750
JUC
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4241
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
Java多线程编程——对象及变量的并发访问 02
ECHO_FOLLOW_HEART的专栏
08-11 533
Java多线程编程——对象及变量的并发访问 02synchronized同步方法 方法内的变量为线程安全：运行时，入栈操作，故为线程安全 实例(对象)变量非线程安全：运行时，在堆中，故为非线程安全 关键字synchronized取得的锁都是对象锁 synchronized锁重入：当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。 异常时，自动释放锁 同步不能继承 synchr
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day22】—— 并发编程2
陈哈哈的菜园子
07-08 1万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！今天是并发编程2，看什么看？快上车！
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
Java并发编程图册Java并发编程图册
最新发布
03-29
首先，我们需要理解Java并发编程的基础——线程。在Java中，通过`Thread`类或者实现`Runnable`接口来创建线程。线程是程序执行的最小单位，允许多个任务在同一时间内执行。通过线程，我们可以实现并行处理，提升程序...
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
Android开发艺术探索读书笔记（二）
热门推荐
amurocrash的专栏
09-25 1万+
首先感谢大家支持，昨天第一篇写出来之后反响很好，主席本人也非常赞赏（捂脸～），再接再厉，推出第二篇。这篇的主要内容是对两章View的内容进行总结。不得不说，自定义View是很多开发者的痛点，一方面我们很羡慕大神们做出骚气又酷炫的界面，另一方面我们又苦于网上的资料过于凌乱和纷杂导致很多时候越学越晕。尤其工科，想要深入掌握某种知识，体系化是非常重要的，就像我们必须先学四则运算，才能进阶到更复杂的开方乘方
Android开发艺术探索读书笔记（三）
amurocrash的专栏
10-06 1万+
日以继夜近两个星期，终于完成这篇了，之所以自己这么看重，是因为这篇应该是读书笔记里最重要的一篇了，这篇能吃透的话，基本安卓app层玩的机制都能理解的很清楚了，所以我也倾注了全部的心血来写这篇，希望跟大家一起分享。 简单先说下：这里将第九章（四大组件的工作过程），第十章（Android的消息机制）放在第八章（理解Window和WindowManager）前面的原因是：学习理解Window的知识最好
Android开发艺术探索读书笔记（一）
amurocrash的专栏
09-24 9478
首先向各位严重推荐主席这本书《Android开发艺术探索》。     再感谢主席邀请写这篇读书笔记 ＋ 书评。书已经完整的翻完一遍了，但是还没有细致的品读并run代码，最近有时间正好系统的把整本书从内容到代码都梳理一遍，一方面方便自己总结，一方面也为主席宣传，如果你还在犹豫要不要入手这本书的时候，希望看完我的笔记，能激发你购买的动力。OK，言归正传，下面先简单写几句书评，本人技术有限，只是从自身
J2EE学习笔记（一）
amurocrash的专栏
11-23 483
零碎的记录一些重要但容易遗忘的point，感觉上帝就没给我点这个记忆力的技能……$. WEB-INF目录详解 WEB-INF目录客户端无法访问，只有服务器可以访问； classes文件夹，放置.class文件； lib文件夹，放置项目需要的jar包； web.xml，项目部署文件；$. web.xml中配置首页（直接url项目名称就能打开的页面）<welcome-file-list>
JavaScript设计模式（一）
amurocrash的专栏
12-05 472
Intro 一直很感兴趣对于JavaScript这样的动态类型语言，没有强类型也没有接口要怎么通过设计模式写出优雅的代码。这次一口气读完了腾讯出的一本关于JS设计模式的书，非常有启发，这里写一个小的系列给大家分享。还是那句话，设计是为了更好的解决问题，而不是为了设计而设计，所以重要的是理解思想，而不是当成一个模板去套。毕竟设计模式会带来性能的损耗和他人阅读代码学习成本的上升，如非必要，勿增实体，
Algorithm Review 1 基础排序算法
amurocrash的专栏
04-17 451
整天做上层架构设计和写界面，把计算机最重要的算法与数据结构都忘得差不多了。所以从这篇开始系统地复习常见的算法与数据结构，这里会暂时抛弃Java，用C++来做，因为即使是Android系统，算法实现也大多是通过C或者C++编译成so来实现的。对于算法的描述我会尽量抛弃复杂的理论描述，尽量用大白话来让大家好理解。 第一篇是关于普通数组排序的，默认排序都是从小到大~ 一、冒泡排序 算法复杂度n^2
Java并发编程：详解Lock锁与条件变量实战
本文将深入探讨Java并发编程中的核心概念——Lock锁和条件变量。Java 5引入了Lock接口，这是对传统`synchronized`同步机制的增强，提供更为灵活且可控的并发控制。Lock接口主要有三个实现类：ReentrantLock、Read...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值