java多线程系列(二)---对象变量并发访问

2023年12月22日 242次阅读来源: jiajun_geek

对象变量的并发访问

前言：本系列将从零开始讲解java多线程相关的技术，内容参考于《java多线程核心技术》与《java并发编程实战》等相关资料，希望站在巨人的肩膀上,再通过我的理解能让知识更加简单易懂。

线程安全

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据

局部变量并不会数据共享

public class T1 {
    public static void main(String[] args) {
        PrivateNum p=new PrivateNum();
        MyThread threadA=new MyThread('A',p);
        MyThread threadB=new MyThread('B',p);
        threadA.start();
        threadB.start();
    }}
    class MyThread extends Thread
    {
        char i;
        PrivateNum p;
        public MyThread(char i,PrivateNum p)
        {
            this.i=i;
            this.p=p;
        }
        public void run()
        {
            p.test(i);
        }
    }
    class PrivateNum
    {
        
        public void test( char i) 
        {
            try {
                int num=0;
                if(i=='A')
                {
                    num=100;
                    
                    System.out.println("线程A已经设置完毕");
                    Thread.sleep(1000);
                }
                else
                {
                    num=200;
                    System.out.println("线程B已经设置完毕");
                }
                System.out.println("线程"+i+"的值："+num);
                
            }
         catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }}
    }
    
    线程A已经设置完毕
    线程B已经设置完毕
    线程B的值：200
    线程A的值：100

在这段代码中，线程A和B先后对num进行赋值，当两个线程都赋值后再分别打印，但是输出的结果并不相同，后赋值的线程并没有对num的值进行覆盖，因为这里的num是在方法里面的，也就是局部变量，不同线程的num并不共享，所以并不会发生覆盖。

实例成员变量数据共享

public void test( char i) 
        {
            int num=0;
            try {
            
                if(i=='A')
                {
                    num=100;
                    
                    System.out.println("线程A已经设置完毕");
                    Thread.sleep(1000);
                }
                else
                {
                    num=200;
                    System.out.println("线程B已经设置完毕");
                }
                System.out.println("线程"+i+"的值："+num);
                
            }
         catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }}
        线程B已经设置完毕
    线程A已经设置完毕
    线程B的值：200
    线程A的值：200

这里的代码只是将int num=0放到了方法的外面，但是输出的结果却不同，因为这时候线程AB访问的是同一个变量（指向同一个地址），所以这个时候会发生覆盖，同时这里出现了线程安全问题。

synchronized关键字可以避免线程安全问题

public synchronized void test( char i) 
        {
            int num=0;
            try {
            
                if(i=='A')
                {
                    num=100;
                    
                    System.out.println("线程A已经设置完毕");
                    Thread.sleep(1000);
                }
                else
                {
                    num=200;
                    System.out.println("线程B已经设置完毕");
                }
                System.out.println("线程"+i+"的值："+num);
                
            }
         catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }}
    线程A已经设置完毕
    线程A的值：100
    线程B已经设置完毕
    线程B的值：200

这里只是上面代码的基础上增加了一个synchronized ，避免了线程安全问题

总结

如果多个线程访问的是同一个对象方法中的局部变量，那么这个变量并不共享，线程AB对此变量的操作将互不影响
如果多个线程访问的是同一个对象方法中的成员变量，那么这个变量共享，如果不处理好线程问题，可能会出现线程安全问题
通过synchronized关键字可以使方法同步

多个线程访问的是两个不同实例的同一个同步方法

public class T1 {
    public static void main(String[] args) {
        PrivateNum p1=new PrivateNum();
        PrivateNum p2=new PrivateNum();
        MyThread threadA=new MyThread('A',p1);
        MyThread threadB=new MyThread('B',p2);
        threadA.start();
        threadB.start();
    }}
    线程A已经设置完毕
    线程B已经设置完毕
    线程B的值：200  
    线程A的值：100

这里的代码又是在上面的代码进行修改，这里我们添加了synchronized关键字，对方法上锁，但是却是异步执行的（同步的话，应该是这样输出 线程A已经设置完毕线程A的值：100 ）,这是因为这里是两个锁，创建了p1和p2对象，创建的是两个锁，锁对象不同不造成互斥作用。

多线程调用同一个实例的两个不同（一个同步，一个非同步）方法

public class T1 {
    public static void main(String[] args) {
        PrivateNum p1=new PrivateNum();
    
        MyThread threadA=new MyThread('A',p1);
        MyThread2 threadB=new MyThread2('B',p1);
        threadA.start();
        threadB.start();
    }}
    class MyThread extends Thread
    {
        char i;
        PrivateNum p;
        public MyThread(char i,PrivateNum p)
        {
            this.i=i;
            this.p=p;
        }
        public void run()
        {
            p.test(i);
        }
    }
    class MyThread2 extends Thread
    {
        char i;
        PrivateNum p;
        public MyThread2(char i,PrivateNum p)
        {
            this.i=i;
            this.p=p;
        }
        public void run()
        {
            p.test2(i);
        }
    }
    class PrivateNum
    {
        int num=0;
        public void test2(char i)
        {
            System.out.println("线程"+i+"执行，线程A并没有同步执行");
        }
        public synchronized void  test( char i) 
        {
            
            try {
                
                if(i=='A')
                {
                    num=100;
                    
                    System.out.println("线程A已经设置完毕");
                    Thread.sleep(100);
                }
                else
                {
                    num=200;
                    System.out.println("线程B已经设置完毕");
                }
                System.out.println("线程"+i+"的值："+num);
                
            }
         catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }}
    }
    线程A已经设置完毕
    线程B执行，线程A并没有同步执行
    线程A的值：100
    线程B的值：200

这里的代码我们给PrivateNum添加了一个非同步的test2方法，MyThreadrun中调用的同步的test方法，MyThread2中调用的是非同步的test2方法，实验表明线程B可以异步调用非同步的方法。

多线程调用同一个实例的两个不同的同步方法

    public synchronized void test2(char i)
        {
            System.out.println("线程"+i+"执行，线程A同步执行");
        }
    线程A已经设置完毕
    线程A的值：100
    线程B执行，线程A同步执行
    线程B的值：200

这里的代码我们只是给test2方法添加一个synchronized关键字，这个时候两个线程调用的方法同步执行。

总结

多个线程调用的不同实例的同步方法，线程不互斥。
如果两个线程的锁对象一样（都是p1），两个线程分别调用同步方法和非同步方法，线程不会同步执行。
但是如果调用两个不同的同步方法，因为锁对象一致，两个线程同步执行。
设想一个情况，有一个实例有两个方法，一个修改值（synchronized），一个读值（非synchronized），此时两个线程一个修改值，一个读取值，这个时候因为这两个线程并不会挣抢锁，两个线程互不影响，那么此时可能就会出现一种情况，线程A还没修改完，线程B就读取到没有修改的值。这就是所谓的脏读。

重入锁

public class T1 {
    public static void main(String[] args) {

        MyThread3 thread=new MyThread3();
        thread.start();
    }}
    class MyThread3 extends Thread
    {
        Service s=new Service();
        public void run()
        {
            s.service1();
        }
    }
    class Service
    {
        public synchronized void service1()
        {
            System.out.println("服务1并没有被锁住");
            service2();
        }
        public synchronized void service2()
        {
            System.out.println("服务2并没有被锁住");
            service3();
        }
        public synchronized void service3()
        {
            System.out.println("服务3并没有被锁住");
        }
    }
    服务1并没有被锁住
服务2并没有被锁住
服务3并没有被锁住

我们可能会这么认为，thread线程执行了同步的service1方法，这个时候把锁占住，如果这个时候要执行另一个同步方法service2方法，必须先执行完service1方法，然后把锁让出去才行，但是实验证明锁是可以重入的，一个线程获得锁后，还没释放后可以再次获取锁。

出现异常会释放锁

如果同步方法里面出现异常，会自动将锁释放

同步方法不会继承

public class T1 {
    public static void main(String[] args) {

        Service3 s=new Service3();
        MyThread4 t1=new MyThread4(s,'1');
        MyThread4 t2=new MyThread4(s,'2');
        t1.start();
        t2.start();
        
    }}
    class MyThread4 extends Thread
    {
        Service3 s;
        char name;
        public MyThread4(Service3 s,char name)
        {
            this.s=s;
            this.name=name;
        }
        public void run()
        {
            s.service(name);
        }
        
    }
    class Service2 
    {
        public synchronized void service(char name)
        {
            for (int i = 3; i >0; i--) {
                System.out.println(i);
            }
        }
    }
    class Service3 extends Service2 
    {
        public void service(char name)
        {
            for (int i = 5; i >0; i--) {
                System.out.println("线程"+name+":"+i);
            }
        }
    }
    线程1:5 线程2:5

如果父类的方法是同步的，如果子类重载同步方法，但是没有synchronized关键字，那么是没有同步作用的。

总结

重入锁，一个获得的锁的线程没执行完可以继续获得锁。
线程占用锁的时候，如果执行的同步出现异常，会将锁让出。
父类方法同步，子类重写该方法（没有synchronized关键字修饰），是没有同步作用的。

同步代码块

public class T1 {
    public static void main(String[] args) {
    Service2 s=new Service2();
        MyThread t1=new MyThread(s,'A');
        MyThread t2=new MyThread(s,'B');
        t1.start();
        t2.start();
        
    }
        
    }
    class Service2 
    {
        public  void service(char name)
        {
            synchronized(this)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
    }
    class MyThread extends Thread
    {
        Service2 s=new Service2();
        char name;
        public  MyThread(Service2 s,char name)
        {
            this.s=s;
            this.name=name;
        }
        public void run()
        {
            s.service(name);
        }
    }
    A:3
    A:2
    A:1
    B:3
    B:2
    B:1

当多个线程访问同一个对象的synchronized（this）代码块时，一段时间内只有一个线程能执行

同步代码块的锁对象

class Service2 
    {
        String s=new String("锁");
        public  void service(char name)
        {
            
            synchronized(s)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
        
    }

将this换成自己创建的锁（一个对象），同样可以实现同步功能

部分同步，部分异步

public  void service(char name)
        {
            for (int i = 6; i >3; i--) {
                System.out.println(name+":"+i);
            }
            synchronized(this)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
        A:6
B:6
A:5
B:5
A:4
B:4
A:3
A:2
A:1
B:3
B:2
B:1

不在同步代码块中的代码可以异步执行，在同步代码块中的代码同步执行

不同方法里面的synchronized代码块同步执行

public class T1 {
    public static void main(String[] args) {
    Service2 s=new Service2();
        MyThread t1=new MyThread(s,'A');
        MyThread2 t2=new MyThread2(s,'B');
        t1.start();
        t2.start();
        
    }
        
    }
    class Service2 
    {
        public  void service(char name)
        {
            
            synchronized(this)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
        public void service2(char name)
        {
            synchronized(this)  {
                for (int i = 6; i >3; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
    }
    class MyThread extends Thread
    {
        Service2 s=new Service2();
        char name;
        public  MyThread(Service2 s,char name)
        {
            this.s=s;
            this.name=name;
        }
        public void run()
        {
            s.service(name);
        }
    }
    class MyThread2 extends Thread
    {
        Service2 s=new Service2();
        char name;
        public  MyThread2(Service2 s,char name)
        {
            this.s=s;
            this.name=name;
        }
        public void run()
        {
            s.service2(name);
        }
    }
A:3
A:2
A:1
B:6
B:5
B:4

两个线程访问同一个对象的两个同步代码块，这两个代码块是同步执行的

锁不同没有互斥作用

class Service2 
    {
        Strign s=new String();
        public  void service(char name)
        {
            
            synchronized(s)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
        public void service2(char name)
        {
            synchronized(this)  {
                for (int i = 6; i >3; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
    }

将this改成s，也就是改变锁对象，发现两个方法并不是同步执行的

synchronized方法和synchronized(this)代码块是锁定当前对象的

public  void service(char name)
        {
            
            synchronized(this)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
public synchronized void service2(char name)
        {
                for (int i = 6; i >3; i--) {
                    System.out.println(name+":"+i);
                }
        }

将service2的代码块改成synchronized 方法，发现输出结果是同步的的，说明锁定的都是当前对象

总结

同步代码块的锁对象可以是本对象，也可以是其他对象。同一个锁对象可以产生互斥作用，不同锁对象不能产生互斥作用
一个方法中有同步代码块和非同步代码块，同步代码块的代码是同步执行的（块里的代码一次执行完），而非同步代码块的代码可以异步执行
一个对象中的不同同步代码块是互斥的，执行完一个代码块再执行另一个代码块
同步代码块(this)和synchronized方法的锁定的都是当前对象 this

syncronized static 同步静态方法

class Service2 
    {
        
        public  synchronized static void service()
        {
            
            
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            
        }
        
    }

在这里锁对象就不是service对象，而是Class（Class（和String Integer一样）是一个类）

Class锁

class Service2 
    {
        
        public   static void service()
        {
            
            
                synchronized(Service.class)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
            
        }
        
    }

这里的效果和上面静态的synchronized一样

静态类中非静态同步方法

public class T1 {
    public static void main(String[] args) {

        Service.Service2 s=new Service.Service2();
        Thread t1=new Thread(new Runnable()
                {public void run(){s.service();}});
        Thread t2=new Thread(new Runnable()
        {public void run(){Service.Service2.service2();}});
        t1.start();
        
        t2.start();
    }
    
    
    
    }
    class Service{
    static class Service2 
    {
        
        public synchronized   void service()
        {
            

                for (int i = 20; i >10; i--) {
                    
                    System.out.println(i);
                }
            
        }
        public static synchronized void service2()
        {
            for (int i = 9; i >3; i--) {
                System.out.println(i);
            }
        }
        
    }}
    //不同步执行

这里service方法的锁还是service对象，

总结

Class类也可以是锁，Class锁的实现可以通过静态的synchronizd方法，也可以通过静态方法里面的同步代码块（锁对象为Class）
静态类的同步方法锁对象还是该类的一个实例

死锁

public class DealThread implements Runnable {

    public String username;
    public Object lock1 = new Object();
    public Object lock2 = new Object();

    public void setFlag(String username) {
        this.username = username;
    }

    @Override
    public void run() {
        if (username.equals("a")) {
            synchronized (lock1) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("按lock1->lock2代码顺序执行了");
                }
            }
        }
        if (username.equals("b")) {
            synchronized (lock2) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("按lock2->lock1代码顺序执行了");
                }
            }
        }
    }

}

线程AB开始执行时，因为锁不同，所以不互斥，A当执行到另一个同步代码块（锁2）的时候，由于这个时候锁给线程B占有了，所以只能等待，同样B线程也是如此，AB互相抢对方的锁，但是所以造成了死锁。

锁对象发生改变

修改锁对象的属性不印象结果，比如此时锁对象为user对象，我把user的name设为jiajun，此时不影响结果

volatile

public class Tee {
    public static void main(String[] args) {
    
        try {
            RunThread thread = new RunThread();
            thread.start();
            Thread.sleep(1000);
            thread.setRunning(false);
            System.out.println("已经赋值为false");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }

    
    
    class RunThread extends Thread {

         private boolean isRunning = true;

        public boolean isRunning() {
            return isRunning;
        }

        public void setRunning(boolean isRunning) {
            this.isRunning = isRunning;
        }

        @Override
        public void run() {
            System.out.println("进入run了");
            while (isRunning == true) {
            }
            System.out.println("线程被停止了！");
        }

    }

在这里，把vm运行参数设置为-server（右键运行配置，自变量那里可以设置，server参数可以提高运行性能），结果发现虽然我们将值设置为false，但是却仍然进入死循环。
isRunning变量存放在公共堆栈和线程的私有堆栈中，我们对他赋值为false时，只对公共堆栈进行更新，而但我们设置为-server后，读取的是线程私有栈的内容，所以也就造成了死循环。我们可以在isRunning变量前加上volatite关键字，这个时候访问的是公共堆栈，就不会造成死循环了。
以前我们使用单线程的时候，这种情况情况不会发生，但是当多个线程进行读写操作的时候就可能爆发出问题，这是因为我们没有用同步机制来保证他，这是我们需要注意的一点。

public class Tee {
    public static void main(String[] args) {

        MyThread[] mythreadArray = new MyThread[100];
        for (int i = 0; i < 100; i++) {
            mythreadArray[i] = new MyThread();
        }

        for (int i = 0; i < 100; i++) {
            mythreadArray[i].start();
        }
    }

    
 class MyThread extends Thread {
        volatile public static int count;

         private static void addCount() {
            for (int i = 0; i < 100; i++) {
                count++;
            }
            System.out.println("count=" + count);
        }

        @Override
        public void run() {
            addCount();
        }

    }

在这里我们只count前添加volatile，但是最终结果输出的并不是10000，说明并没有同步的作用，volatile不处理数据原子性（i++不是原子操作）
我们将volatile去掉，将addcount方法用synchronized修饰，发现输出了10000，说明了synchronized的同步作用不仅保证了对同一个锁线程的互斥，还保证了数据的同步。

总结

volitate增加了实例变量在对个线程之间的可见性，保证我们获得的是变量的最新值。
volatile在读上面保持了同步作用，但是在写上面不保持同步
synchronized的同步作用不仅保证了对同一个锁线程的互斥，还保证了数据的同步

volatile对比synchronized

两者修饰的不同，volatile修饰的是变量，synchronized修饰的是方法和代码块
两者的功能不同。volatile保证数据的可见性，synchronized是线程同步执行（间接保证数据可见性，让线程工作内存的变量和公共内存的同步）
volatile性能比synchronized性能高

用原子类实现i++同步

class MyThread extends Thread {
        static AtomicInteger count=new AtomicInteger(0);
         private  static void addCount() {
            for (int i = 0; i < 100; i++) {
                count.incrementAndGet();
            }
            System.out.println(count.get());
        }

        @Override
        public void run() {
            addCount();
        }

    }

将上面的count++进行用原子类AtomicInteger改变，最后输出了1000

我觉得分享是一种精神，分享是我的乐趣所在，不是说我觉得我讲得一定是对的，我讲得可能很多是不对的，但是我希望我讲的东西是我人生的体验和思考，是给很多人反思，也许给你一秒钟、半秒钟，哪怕说一句话有点道理，引发自己内心的感触，这就是我最大的价值。（这是我喜欢的一句话，也是我写博客的初衷）

作者：jiajun 出处： http://www.cnblogs.com/-new/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。如果觉得还有帮助的话，可以点一下右下角的【推荐】，希望能够持续的为大家带来好的技术文章！想跟我一起进步么？那就【关注】我吧。

    原文作者：jiajun_geek
    原文地址: https://www.cnblogs.com/-new/p/7190092.html
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。

算法网

java多线程系列(二)---对象变量并发访问

对象变量的并发访问

目录

线程安全

局部变量并不会数据共享

实例成员变量数据共享

synchronized关键字可以避免线程安全问题

总结

多个线程访问的是两个不同实例的同一个同步方法

多线程调用同一个实例的两个不同（一个同步，一个非同步）方法

多线程调用同一个实例的两个不同的同步方法

总结

重入锁

出现异常会释放锁

同步方法不会继承

总结

同步代码块

同步代码块的锁对象

部分同步，部分异步

不同方法里面的synchronized代码块同步执行

锁不同没有互斥作用

synchronized方法和synchronized(this)代码块是锁定当前对象的

总结

syncronized static 同步静态方法

Class锁

静态类中非静态同步方法

总结

死锁

锁对象发生改变

volatile

总结

volatile对比synchronized

用原子类实现i++同步