/**
 * demo1: synchronized的用法
 * 一個執行緒訪問一個物件中的synchronized(this)同步程式碼塊時，其他試圖訪問該物件的執行緒將被阻塞
 */
public class SyncThread extends Thread {

    private static int count;

    public SyncThread() {
        count = 0;
    }

    public  void run() {
        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 int getCount() {
        return count;
    }

    public static void main(String[] args) {

        // 只有一把鎖
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();

        // 會有兩把鎖， syncThread1 對應一把鎖， syncThread2 對應一把鎖
//        SyncThread syncThread1 = new SyncThread();
//        SyncThread syncThread2 = new SyncThread();
//        Thread thread1 = new Thread(syncThread1, "SyncThread1");
//        Thread thread2 = new Thread(syncThread2, "SyncThread2");
//        thread1.start();
//        thread2.start();
    }
}
 

/**
 * demo2 多個執行緒訪問synchronized和非synchronized程式碼塊
 * 程式碼中countAdd是一個synchronized的，printCount是非synchronized的。
 * 從結果中可以看出一個執行緒訪問一個物件的synchronized程式碼塊時，
 * 別的執行緒可以訪問該物件的非synchronized程式碼塊而不受阻塞。
 */
public class Counter implements Runnable {

    private int count;

    public Counter() {
        count = 0;
    }

    public void countAdd() {
        synchronized(this) {
            for (int i = 0; i < 5; i ++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //非synchronized程式碼塊，未對count進行讀寫操作，所以可以不用synchronized
    public void printCount() {
        for (int i = 0; i < 5; i ++) {
            try {
                System.out.println(Thread.currentThread().getName() + " count:" + count);
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            countAdd();
        } else if (threadName.equals("B")) {
            printCount();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter, "A");
        Thread thread2 = new Thread(counter, "B");
        thread1.start();
        thread2.start();
    }
}
 

/**
 * demo3 :指定要給某個物件加鎖
 * 在AccountOperator 類中的run方法裡，我們用synchronized 給account物件加了鎖。
 * 這時，當一個執行緒訪問account物件時，其他試圖訪問account物件的執行緒將會阻塞，
 * 直到該執行緒訪問account物件結束。也就是說誰拿到那個鎖誰就可以執行它所控制的那段程式碼。
 */
public class Demo3 {

    /**
     * 銀行賬戶類
     */
    class Account {
        String name;
        float amount;

        public Account(String name, float amount) {
            this.name = name;
            this.amount = amount;
        }
        //存錢
        public  void deposit(float amt) {
            amount += amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取錢
        public  void withdraw(float amt) {
            amount -= amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public float getBalance() {
            return amount;
        }
    }

    /**
     * 賬戶操作類
     */
    class AccountOperator implements Runnable{
        private Account account;

        private byte[] bytes = new byte[0];

        public AccountOperator(Account account) {
            this.account = account;
        }

        @Override
        public void run() {
            synchronized (account) {
                account.deposit(500);
                account.withdraw(500);
                System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
            }
//            account.deposit(500);
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            account.withdraw(500);
//            System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
        }
    }

    public void test() {
        Account account = new Account("zhang san", 10000.0f);
        AccountOperator accountOperator = new AccountOperator(account);

        final int num = 5;
        Thread threads[] = new Thread[num];
        for (int i = 0; i < num; i ++) {
            threads[i] = new Thread(accountOperator, "Thread" + i);
            threads[i].start();
        }
    }

    public static void main(String[] args) {
      Demo3 d = new Demo3();
      d.test();
    }

}