Synchronized

Author: CodePrometheus

README.md

@@ -35,6 +35,13 @@ Java并发编程
     饥饿
 
 
+## Synchronized
+    作用用法
+    性质
+    原理
+    缺陷
+
+
 ## 原子类
     基本类型原子类
         AtomicInteger

Synchronized/Synchronized.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

Synchronized/src/SynchronizedClassClass.java

@@ -0,0 +1,45 @@
+/**
+ * .class代码块
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 19:14
+ */
+public class SynchronizedClassClass implements Runnable {
+    static SynchronizedClassClass instance1 = new SynchronizedClassClass();
+    static SynchronizedClassClass instance2 = new SynchronizedClassClass();
+
+
+    @Override
+    public void run() {
+        try {
+            method();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void method() throws InterruptedException {
+//        synchronized (this) {
+        synchronized (SynchronizedClassClass.class) {
+            System.out.println("SynchronizedClassClass,I am " + Thread.currentThread().getName());
+            Thread.sleep(3000);
+            System.out.println(Thread.currentThread().getName() + "运行结束");
+        }
+
+    }
+
+
+    public static void main(String[] args) {
+        Thread thread1 = new Thread(instance1);
+        Thread thread2 = new Thread(instance2);
+        thread1.start();
+        thread2.start();
+
+        // 死循环
+        while (thread1.isAlive() || thread2.isAlive()) {
+
+        }
+        System.out.println("finished");
+
+    }
+}

Synchronized/src/SynchronizedClassStatic.java

@@ -0,0 +1,42 @@
+/**
+ * 类锁的第一种形式 -> static形式
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 19:07
+ */
+public class SynchronizedClassStatic implements Runnable {
+
+    static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
+    static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();
+
+    @Override
+    public void run() {
+        method();
+    }
+
+    // 加上static，全局同步方法
+    public static synchronized void method() {
+        System.out.println("SynchronizedClassStatic，I am " + Thread.currentThread().getName());
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println(Thread.currentThread().getName() + "运行结束");
+    }
+
+
+    public static void main(String[] args) {
+        Thread thread1 = new Thread(instance1);
+        Thread thread2 = new Thread(instance2);
+        thread1.start();
+        thread2.start();
+
+        // 死循环
+        while (thread1.isAlive() || thread2.isAlive()) {
+
+        }
+        System.out.println("finished");
+
+    }
+}

Synchronized/src/SynchronizedObjectCodeBlock.java

@@ -0,0 +1,51 @@
+/**
+ * 对象锁之代码块形式
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 18:43
+ */
+public class SynchronizedObjectCodeBlock implements Runnable {
+
+    static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();
+    // 自定义锁
+    Object lock1 = new Object();
+    Object lock2 = new Object();
+
+    @Override
+    public void run() {
+//        synchronized (this) {
+        synchronized (lock1) {
+            System.out.println("SynchronizedObjectCodeBlock,I am " + Thread.currentThread().getName());
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(Thread.currentThread().getName() + "运行结束");
+        }
+
+        // 可以并行执行
+        synchronized (lock2) {
+            System.out.println("SynchronizedObjectCodeBlock,I am " + Thread.currentThread().getName());
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println(Thread.currentThread().getName() + "运行结束");
+        }
+    }
+
+    public static void main(String[] args) {
+        Thread thread1 = new Thread(instance);
+        Thread thread2 = new Thread(instance);
+        thread1.start();
+        thread2.start();
+
+        // 死循环
+        while (thread1.isAlive() || thread2.isAlive()) {
+
+        }
+        System.out.println("finished");
+    }
+}

Synchronized/src/SynchronizedObjectMethod.java

@@ -0,0 +1,38 @@
+/**
+ * 方法锁
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 19:00
+ */
+public class SynchronizedObjectMethod implements Runnable {
+    static SynchronizedObjectMethod instance = new SynchronizedObjectMethod();
+
+    @Override
+    public void run() {
+        method();
+    }
+
+    public synchronized void method() {
+        System.out.println("SynchronizedObjectMethod，I am " + Thread.currentThread().getName());
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println(Thread.currentThread().getName() + "运行结束");
+    }
+
+    public static void main(String[] args) {
+        Thread thread1 = new Thread(instance);
+        Thread thread2 = new Thread(instance);
+        thread1.start();
+        thread2.start();
+
+        // 死循环
+        while (thread1.isAlive() || thread2.isAlive()) {
+
+        }
+        System.out.println("finished");
+    }
+
+}

Synchronized/src/SynchronizedSummary.java

@@ -0,0 +1,40 @@
+/**
+ * Synchronized使用总结
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 18:31
+ */
+public class SynchronizedSummary {
+
+    /**
+     * JVM会自动通过使用monitor来加锁和解锁，保证了同时只有一个线程可以执行指定代码，从而保证了线程安全，具有可重入和不可中断的性质
+     */
+
+    /**
+     *  作用 ->
+     *     能够保证在 同一时刻❗ 最多 只有一个❗ 线程执行该段代码，以达到保证并发安全的效果
+     */
+
+
+    /**
+     *  对象锁
+     *    -> 包括方法锁（默认锁对象为this当前实例对象）和 同步代码块锁（自己指定锁对象）
+     *  类锁
+     *    -> 指synchronized修饰静态的方法或指定锁为Class对象
+     */
+
+    /**
+     *  几种情况
+     *    -> 一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待
+     *    -> 每个实例都对应有自己的一把锁，不同实例之间互不影响，例外：锁对象是.class以及synchronized修饰的是static时，所有的对象共用同一把类锁
+     *    -> 无论是方法正常执行完毕或者方法抛出异常，都会释放锁
+     *    -> 另外，在synchronized中调用了没有被synchronized修饰的方法，不是线程安全的！
+     */
+
+    /**
+     * 缺陷 ->
+     *  效率低：锁的释放情况少，视图获得锁时不能设定超时，不能中断一个正在试图获得锁的线程
+     *  不够灵活：加锁和释放的时机单一
+     *  无法知道是否成功获得锁
+     */
+}

Synchronized/src/SynchronizedToLock.java

@@ -0,0 +1,34 @@
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 加锁和释放锁的原理
+ *
+ * @Author: zzStar
+ * @Date: 10-21-2020 19:45
+ */
+public class SynchronizedToLock {
+
+    Lock lock = new ReentrantLock();
+
+    public static void main(String[] args) {
+        SynchronizedToLock synchronizedToLock = new SynchronizedToLock();
+        synchronizedToLock.method1();
+        synchronizedToLock.method2();
+    }
+
+    public synchronized void method1() {
+        System.out.println("synchronized形式的锁");
+    }
+
+    // 等价方法
+    public void method2() {
+        lock.lock();
+        try {
+            System.out.println("我是lock形式的锁");
+        } finally {
+            lock.unlock();
+        }
+    }
+
+}