多线程与高并发(三)synchronized关键字
发布日期:2021-05-09 09:07:34 浏览次数:12 分类:博客文章

本文共 21671 字,大约阅读时间需要 72 分钟。

������������������������������������������������������������������������������������������JMM������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������java���������������synchronized������������������������������������������������������������������������������������������������������������������������������

������������synchronized

������������������������������synchronized���������������������������������������������������������������������synchronized���������

������ ������������ ������������ ���������
������ ������������ ������������������ public synchronized void method(){}
������������ ��������� public static synchronized void method(){}
��������� ������������ ������������������ synchronized(this){}
class������ ��������� synchronized(Demo.class){}
���������������������Object ������������Object String lock="";synchronized(lock){}

synchronized������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������new������������������������������������������������������������������������������������������������������������������

1.1 ������������

������������������������������

public class SynchronizedDemo1 {private int count;public void countAdd() {    for (int i = 0; i < 5; i++) {        try {            System.out.println(Thread.currentThread().getName() + ":" + (count++));            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }    }}public static void main(String[] args) {    SynchronizedDemo1 demo1 = new SynchronizedDemo1();    new Thread(new Runnable() {        @Override        public void run() {            demo1.countAdd();        }    }).start();    new Thread(new Runnable() {        @Override        public void run() {            demo1.countAdd();        }    }).start();}}

���������������synchronized���������������������

1.1.1 ������������

 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������synchronized���������������������������

public synchronized void countAdd()

���������������������

������������������Thread-1������������������Thread-0������������������������������������������Thread-0���Thread-1���������������countAdd������������

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������synchronized���������������������������������������������������������������������������������������������������������������������������������������

public void print() {    System.out.println(Thread.currentThread().getName() + "���������������:" + count);}

������������������������

public static void main(String[] args) {        SynchronizedDemo1 demo1 = new SynchronizedDemo1();        new Thread(new Runnable() {            @Override            public void run() {                demo1.countAdd();            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                demo1.print();                demo1.countAdd();            }        }).start();    }

���������������Thread-1������������������������������Thread-0������������������������������������������������synchronized���������������������������������������������������������

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

1.1.2 ������������

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

public class SynchronizedDemo2 {    private static int count;    public static synchronized void countAdd() {        for (int i = 0; i < 5; i++) {            try {                System.out.println(Thread.currentThread().getName() + ":" + (count++));                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    public static void main(String[] args) {        SynchronizedDemo2 demo1 = new SynchronizedDemo2();        SynchronizedDemo2 demo2 = new SynchronizedDemo2();        new Thread(new Runnable() {            @Override            public void run() {                demo1.countAdd();            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                demo2.countAdd();            }        }).start();    }}

���������

������������������������������������������������������������������������������������������������

1.2 ���������������

synchronized������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

public class SynchronizedDemo3 {    private int count;    public void countAdd() {        synchronized (this) {            for (int i = 0; i < 5; i++) {                try {                    System.out.println(Thread.currentThread().getName() + ":" + (count++));                    Thread.sleep(100);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) {        SynchronizedDemo3 demo1 = new SynchronizedDemo3();        new Thread(new Runnable() {            @Override            public void run() {                demo1.countAdd();            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                demo1.countAdd();            }        }).start();    }}

������������������������������������������������this������������������������������������������������������������������������������������������������������������

������������������ synchronized (this)������synchronized (SynchronizedDemo3.class)���������������������������������������������������������������������������������

������������������

synchronized������������������������������������������������������������������������������������������������

2.1 ������������monitor���������

������������������������������

public class SynchronizedDemo {    public static void main(String[] args) {        synchronized (SynchronizedDemo.class) {        }        method();    }    private synchronized static void method() {    }}

���������������������������������������������������������������������SynchronizedDemo.class������������������javap -v SynchronizedDemo.class������������������������

���������������������������������������������������������������������monitorenter������������������������monitorexit���������������Synchronized������������������������������������������������������������monitor������������������������������monitor���������������������������������������������������������������������������������������������������������������������������������������������monitor������������demo���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������monitorexit������������������monitorenter������������������������������������������������������������������������������������������������������������������Synchronized������������������������������������������������������������������������������������������������������������������������������������������������������������

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������BLOCKED���������

���������������Object���������������������������Object���������������������������������������������������������������������������������������BLOCKED������Object������������������������������������������������������������������������������������������������������

2.2 synchronized���happens-before������

���������������Synchronized���happens-before���������������������������

 

public class MonitorDemo {    private int a = 0;    public synchronized void writer() {     // 1        a++;                                // 2    }                                       // 3    public synchronized void reader() {    // 4        int i = a;                         // 5    } }

������������happens-before���������������������

���������������������������������������������������������������happens-before���������������������������������������������������������������������������������������������������������������A���������happens-before������B���������������������������������������������������������������������������������happens-befor������������������������������������������������happens-before������������������������������������2 happens-before 5������������������������������������������������

������happens-before���������������������:������A happens-before B������A������������������B���������������A���������������������B���������A������������������A������������������2 happens-before 5������������������A������������������������B���������������B���������������a���������1���

2.3 ������������������������������������

���������������������������JMM������������������������happens-before������������������������������������������������Synchronized���happens-before���������������������������������������������������������������java���������������������Synchronized������������������

���������������������������������

������������������������������A���������������������������������������������a=0������������������������������������������������������������������������������������������������������������������������������������������A ������-->���������������������-->������������������������������������

������B������������������������������������������������������a���������������������������������������1,������������������������������B���������������������������������������������������������������������������

���������������������������A������������������a=1������������B���������������������������������������������������������������������������������������������������������������������������������������������������������������������������2 happens-before 5���2������������������5���������������

���������������������������������A������������������������������������������B���������������A ������ B ���������������������������������1������������������������������������������������java������������������������������������������������������������

3.4 ���������

������������������������������������monitor,������������������������������������������������������������������������������������������������������������������������������������������Java���������������������

jvm���������2������������������������(���������������������������������3���������������������1������������������������������)������������������������Mark Word ��� Class Metadata Address ������������������������������������

������Mark Word������������������������������������HashCode������������������������������������������32���JVM���Mark Word������������������

������������������������������������������������������������������������������������������������������������JVM������������������Mark Word ������������������������������������������������������������������������������������������������������������������������������������������������������32���JVM���������������������������Mark Word������������������������������������������������������������

������������

���������������������������������synchronized���������������������������������������������������������������������������������������������������������

synchronized������������������������������������������BLOCKED������������������������������������������������RUNNABLE������������������������������������������������������������������������������������������������������

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

3.1 CAS

CAS������������������������������������������������������������������������������������

3.1.1 CAS���������

���������������������Synchronized���������������������������������������������������������������������������������������CAS���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������CAS(compare and swap)���������������������������������������������������������������������������������������������������������������������

3.1.2 CAS���������������

CAS���������������Compare And Swap������������������������������������������������

CAS���������������������3���������������������������������V������������������O���������������������N���

���������������������������������������������������������O���������������V���������������������������������������������������V���������������������N���

������O���V������������������������������������������������������������������O���������������������������������������������������N������V���������V������������������������������CAS���������������������������������������������������������������������������������������������������������������������������������������������������������������

������������Synchronized(������������)������������������������������������������������������������������������������������������������������������������������������������������������������������������������CAS���������������������������������������CAS������������������������������������������������������������������������������������������������������������������������������������������������������

���J.U.C������������CAS������������������������������������������������concurrency������������������Lock���������������CAS������state������������atomic������������������������������������CAS������������������������������������������������������������������������������������������������������������������

3.1.3 CAS���������

1. ABA������ ������CAS������������������������������������������������������������������������������������������������A������������B������������������A���������������CAS���������������������������������������������A������������������������������������������������������������������������������������������������������������������������������������������������������������������A->B->A������������1A->2B->3C���

2. ������������������

������CAS���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������JVM���������������������������pause���������������������������������������������������

3. ���������������������������������������������

���������������������������������������CAS���������������������������������������������������������������,CAS���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������CAS������������������������������������atomic������������AtomicReference������������������������������������������

3.2 ������

Java SE 1.6������������������4������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

3.2.1 ���������

������������������������������������������������������������������������������������������������������������������������������������������������������������������(������������������CAS������,������)������������������������������

���������������

������������������������������������������������������������������������������������������������������������������ID���������������������������������������������������������������CAS������������������������������������������������������������������Mark Word������������������������������������������������������������������������������������������������������������������������������������������������������Mark Word������������������������������������1���������������������������������������������������������������CAS���������������������������������������������CAS���������������������������������������������

���������������

������������������������������������������������������������������������������������������������������������������������������������������������������������

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Mark Word������������������������������������������������������������������������������������������������������������������������������������

���������������

������������Java 6���Java 7���������������������������������������������������������������������������������������������������������JVM������������������������-XX:BiasedLockingStartupDelay=0���������������������������������������������������������������������������������������������JVM������������������������-XX:-UseBiasedLocking=false���������������������������������������������������

������������������������������������������������������������������������������������������������������Mark Word ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

3.2.2 ������������

������������������������������������������������������������������������������������������������������������������������������������(1.6���������������)���������Mark Word ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

3.2.3 ���������

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������(������������������������������)���������������������������������50������������100���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

3.2.4 ������������������

���������������������������������������������������Java���������������������

上一篇:Linux(二)各种实用命令
下一篇:多线程与高并发(二)线程安全

发表评论

最新留言

路过,博主的博客真漂亮。。
[***.116.15.85]2025年04月07日 01时50分22秒