对象锁的同步与异步

同步：synchronized

　　同步的概念就是共享 , 如果不是共享的资源 , 就没有必要进行同步。

异步:asynchronized

　　异步的概念就是独立 , 相互之间不受到任何制约。

同步的目的就是为了线程安全 , 其实对于线程安全来说 , 需要满足两个特性：

• 原子性 (同步)：同步性就是一个事物要么一起成功，要么一起失败。
• 可见性：就是一个线程的操作可以及时被其他线程感知到。

package com.itdoc.multi.sync003;

/**
 * 对象锁的同步与异步
 *
 * @author Wáng Chéng Dá
 * @create 2017-03-20 11:36
 */
public class MyObject {

    public synchronized void method1() {
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void method2() {

        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final MyObject mo = new MyObject();

        /**
         * 分析:
         * t1 线程先持有对象锁, t2 线程可以以异步的方式调用对象中的非 synchronized 修饰的方法。
         * t1 线程现持有对象锁, t2 线程若是要调用对象中的同步方法 (synchronized 修饰的方法),
         * 需要等 t1 线程之行结束将对象锁释放后才开始执行 (同步)。
         * 若是静态方法 .class 类锁, 效果一样。
         * 注意: 线程之间必须是相同的锁才可谈论异步同步问题。
         */
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                mo.method1();
            }
        }, "T1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                mo.method2();
            }
        }, "T2");
        t1.start();
        t2.start();
    }
}

 脏读：

package com.itdoc.multi.sync004;

/**
 * 业务整体需要使用完整的 synchronized, 保持业务的原子性。
 *
 * @author Wáng Chéng Dá
 * @create 2017-03-20 13:52
 */
public class DirtyRead {

    private String username = "z3";

    private String password = "123";

    public synchronized void setValue(String username, String password) {
        this.username = username;
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.password = password;
        System.out.println("setValue 最终结果: username = " + username + " -- password = " + password);
    }

    public synchronized void getValue() {
        System.out.println("getValue 方法得到: username = " + this.username + " -- password = " + this.password);
    }

    public static void main(String[] args) throws InterruptedException {
        final DirtyRead dirtyRead = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                dirtyRead.setValue("z3", "456");
            }
        }, "T1");
        t1.start();
        Thread.sleep(1000);
        dirtyRead.getValue();
    }
}

若方法不同步 , 在 t1 线程执行睡眠时, 主线程已经执行完成 , 并打印出 getValue 方法得到: username = z3 -- password = 123 这种数据 , 只有方法同步 , 才能保持业务的原子性。