JUC系列：（三）同步

synchronized(锁对象){
	// 访问共享资源的核心代码
}

// 同步方法
修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}
// 同步静态方法
修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

public class SyncTest {
    
    public void syncBlock(){
        // 代码块
        synchronized (this){
            System.out.println("hello block");
        }
    }
    
    // 方法上加synchronized
    public synchronized void syncMethod(){
        System.out.println("hello method");
    }
}

public class SpinLock {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        while (!atomicReference.compareAndSet(null, thread)) {
            Thread.sleep(1000);
        }
    }

    public void unlock() {
		atomicReference.compareAndSet(thread, null);
    }
}

public static String concatString(String s1, String s2, String s3) {
    return s1 + s2 + s3;
}

public static String concatString(String s1, String s2, String s3) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}

new Thread(() -> {
    synchronized(resources1){
        Thread.sleep(2000);
        synchronized (resources2){
            System.out.println("Thread-1 do sth");
        }
}).start();
    
new Thread(() -> {
    synchronized(resources2){
        Thread.sleep(2000);
        synchronized (resources1){
            System.out.println("Thread-2 do sth");
        }
    }}
}).start();

// Object类API
public final void notify()		// 唤醒正在等待对象监视器的单个线程。
public final void notifyAll()	// 唤醒正在等待对象监视器的所有线程。
public final void wait()		// 导致当前线程等待，直到另一个线程调用该对象的 notify() 方法或 notifyAll()方法。
public final native void wait(long timeout)	// 有时限的等待, 到n毫秒后结束等待，或是被唤醒

synchronized (room) {
    while (!condition) {
        try {
            room.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth
}

// 先park再unpark；先unpark再park，最终结果是一样的，都能恢复线程的运行

Thread t1 = new Thread(() -> {
    Thread.sleep(2000);
    System.out.println("park...");
    LockSupport.park();
    System.out.println("resume...");
},"t1");

t1.start();
Thread.sleep(1000);

LockSupport.unpark(t1);

Hashtable table = new Hashtable();

// 线程1，线程2
if (table.get("key") == null) {
	table.put("key", value);
}

class GuardedObject {
    private Object response;
    private final Object lock = new Object();
    
    public Object get(long millis) {
        synchronized (lock) {
            long begin = System.currentTimeMillis();
            long timePassed = 0;
            while (response == null) {
                long waitTime = millis - timePassed;
                if (waitTime <= 0) {
                    break;
                }
                try {
                    lock.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                timePassed = System.currentTimeMillis() - begin;
            }
            return response;
        }
    }
    
    public void complete(Object response) {
        synchronized (lock) {
            this.response = response;
            lock.notifyAll();
        }
    }
}

GuardedObject guard = new GuardedObject();

new Thread(() -> {
    Thread.sleep(1000);
    guard.complete("123");

}).start();

Object object = guard.get(2000);	// 阻塞获取object的值，最多等待2000毫秒

class Mailboxes {
    private static Map<Integer, GuardedObject> boxes = new Hashtable<>();
    private static int id = 1;

    //产生唯一的id
    private static synchronized int generateId() {
        return id++;
    }

    public static GuardedObject getGuardedObject(int id) {
        return boxes.remove(id);
    }

    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }

    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
}

class GuardedObject {
    // getter，setter，构造函数
    private int id;

    // 其他代码和之前一样
}

for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        Object object = guardedObject.get(10000);
        System.out.println("object = " + object);
    }).start();
}

Thread.sleep(1000);


for (Integer id : Mailboxes.getIds()) {
    final int finalId = id;
    new Thread(() -> {
        GuardedObject guard = Mailboxes.getGuardedObject(finalId);
        Thread.sleep(1000);
        guard.complete("hello" + finalId);
    }).start();
}

Thread t1 = new Thread(() -> {
    while (true) {
        LockSupport.park();
        System.out.println("1");
    }
});

Thread t2 = new Thread(() -> {
    while (true) {
        System.out.println("2");
        LockSupport.unpark(t1);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
});

t1.start();
t2.start();