java synchronized用法详解

客官°小女子只卖身不卖艺 2022-01-14 14:41 282阅读 0赞

参考链接：[https://blog.csdn.net/evankaka/article/details/44153709][https_blog.csdn.net_evankaka_article_details_44153709]  
线程运行状态图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70]  
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1.  修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；
2.  修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3.  修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4.  修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

--------------------

# 同一个实例，不同的线程 #

首先看下面的代码：

package com.example.demo;
    
    public class SynchronizedTest { 
        public static void main(String[] args)
                throws Exception { 
            AccountingSyncClass accountingSyncClass = new AccountingSyncClass();
            Thread t1 = new Thread(accountingSyncClass);
            Thread t2 = new Thread(accountingSyncClass);
            t1.start();
            t2.start();
            t2.join();
            t1.join();
            System.out.println(accountingSyncClass.i);
        }
    
        public void getName2() { 
            System.out.println(SynchronizedTest.class.getName());
        }
    }
    
    class AccountingSyncClass implements Runnable { 
        static int i = 0;;
        static boolean flag = true;
    
        // 作用于静态方法,锁是当前class对象,也就是AccountingSyncClass类对应的class对象
        public static synchronized void increase() { 
            i++;
            System.out.println(Thread.currentThread().getName() + "i:" + i);
        }
    
        // 非静态方法，锁定当前实例对象
        public synchronized void increase2() { 
            i++;
            System.out.println(Thread.currentThread().getName() + "i:" + i);
        }
    
        @Override
        public void run() { 
            for (int j = 0; j < 100; j++) { 
    			//increase();
                increase2();
            }
        }
    }

increase2是非静态方法，创建了一个实例，然后同时开两个线程。

AccountingSyncClass accountingSyncClass = new AccountingSyncClass();
    Thread t1 = new Thread(accountingSyncClass);
    Thread t2 = new Thread(accountingSyncClass);

这两个线程访问的同一个对象，因此使用synchronized修饰，两个线程互不打扰  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 1]  
从运行结果来看，先执行Thread-0 100次，然后执行Thread1 100次，两个线程依次执行，因为没有使用sleep或者Thread.yield（）来使得该线程从运行状态到待运行状态。

public synchronized void increase2() { 
            i++;
            System.out.println(Thread.currentThread().getName() + " i:" + i);
            try { 
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            Thread.yield();
        }

--------------------

# 不同的实例，不同的线程 #

下面我们更改代码：

AccountingSyncClass accountingSyncClass = new AccountingSyncClass();
    Thread t1 = new Thread(new AccountingSyncClass());
    Thread t2 = new Thread(new AccountingSyncClass());
    t1.start();
    t2.start();
    t2.join();
    t1.join();

然后运行：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 2]  
可以看到，两个线程交替运行，但是最后i的结果不是200，是192。  
原因：因为synchronized不是修饰的类静态方法，因此两个实例，两个线程，线程之间对于静态变量i不是互斥的。

synchronized aMethod()\{\}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例的synchronized方法；

--------------------

# 不同对象，不同线程访问静态方法 #

public static synchronized void increase() { 
            i++;
            System.out.println(Thread.currentThread().getName() + "i:" + i);
        }

上面的方法是静态方法，即使使用不同的对象，也是互斥的，最后i的结果仍然是200  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 3]

--------------------

# Synchronized块 #

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

package com.example.demo;
    
    public class MyThreadPrinter2 implements Runnable { 
    
        private String name;
        private Object prev;
        private Object self;
    
        private MyThreadPrinter2(String name, Object prev, Object self) { 
            this.name = name;
            this.prev = prev;
            this.self = self;
        }
    
        @Override
        public void run() { 
            int count = 10;
            while (count > 0) { 
                synchronized (prev) { 
                    synchronized (self) { 
                        System.out.print(name);
                        count--;
                        self.notify();
                    }
                    try { 
                        prev.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
    
            }
        }
    
        public static void main(String[] args) throws Exception { 
            Object a = new Object();
            Object b = new Object();
            Object c = new Object();
            MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
            MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
            MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);
    
    
            new Thread(pa).start();
            Thread.sleep(100);  //确保按顺序A、B、C执行
            new Thread(pb).start();
            Thread.sleep(100);
            new Thread(pc).start();
            Thread.sleep(100);
        }
    }

运行结果：  
![在这里插入图片描述][20190613212352742.png]  
该问题为三个线程之间的同步唤醒操作。  
一个线程必须持有两个对象锁才能继续执行：一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。  
Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作

1.  wait():线程在获取对象锁之后，对锁进行释放，同时本线程休眠，知道有其他线程通过notify()释放该对象才唤醒线程
2.  notify():释放锁，对响应的wait()进行唤醒操作

当线程pa得到c锁和a锁之后，开始执行，执行之后，通过a.notify()释放a，同时线程pb通过prev.wait();也就是a.wait()得到a，开始下一个循环。然后通过c.wait()释放c，同时线程等待直到c释放，c释放在pc线程里面执行self.notify()

--------------------

# wait()和sleep()的相同点以及区别 #

wait和sleep区别  
共同点：

1.  他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2.  wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。  
    如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() \{\} 中直接return即可安全地结束线程。  
    需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点：

1.  Thread类的方法：sleep(),yield()等  
    Object的方法：wait()和notify()等
2.  每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。  
    sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3.  wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用  
    所以sleep()和wait()方法的最大区别是：  
    　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；  
    　　　　而wait()睡眠时，释放对象锁。  
    但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

*  sleep（）方法  
    sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;  
    　　 sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。  
    　　在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
 *  wait（）方法  
    wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；  
    　　wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。  
    　　wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

[https_blog.csdn.net_evankaka_article_details_44153709]: https://blog.csdn.net/evankaka/article/details/44153709
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70]: /images/20220114/1c12d303cea942ce9dcbe9bb5b666fa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 1]: /images/20220114/91e5d5711b9e4699a0b0b9908a23168e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 2]: /images/20220114/db1a149ade454dfe844e38ef194c46ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3Mjg3OQ_size_16_color_FFFFFF_t_70 3]: /images/20220114/a28a81f261f845338d5a049b97120b62.png
[20190613212352742.png]: /images/20220114/f38e5804b1ae42c6b9cb4df1129497d5.png