多线程编程-synchronized

使用取钱的demo来模拟实现线程的同步

 package com.iotec.synchronizedTest;

 import java.io.ObjectInputStream;

 public class BankDemo {
     public static void main(String[] args) {
         Bank bank = new Bank();
         BankThread p1 = new BankThread(bank);
         p1.start();     //柜台取钱
         BankThread p2 = new BankThread(bank);
         p2.start();     //ATM机上取钱

     }
 }

 class BankThread extends Thread{
     private Bank bank = null;
     public BankThread(Bank bank){
         this.bank = bank;
     }

     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"取钱："+bank.getMoney(400));
     }
 }

 class Bank {
     //把竞争访问的资源标识为private
     private int money = 500;

     private Object object = new Object();
     //取钱的方法，返回取钱的数目
     //当一个线程去调用同步方法的时候，这个线程就获得当前对象的锁
     //其它线程当调用同步方法的时候只能等待，因为无法获取对象的锁
     //只有第一个线程释放对象的锁方可进入
 /*    public synchronized int getMoney(int number){
         if(number<0){
             return -1;
         }else if(money<0){
             return -2;
         }else if(number-money>0){
             return -3;
         }else {
             try {
                 Thread.sleep(1000); //模拟取钱的时间
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             money -= number;
             System.out.println("余额："+money);
         }
         return number;
     }*/
     public synchronized int getMoney(int number){
 //        synchronized (this){
         //可以持有的是任何对象
         synchronized (object){
             if(number<0){
                 return -1;
             }else if(money<0){
                 return -2;
             }else if(number-money>0){
                 return -3;
             }else {
                 try {
                     Thread.sleep(1000); //模拟取钱的时间
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 money -= number;
                 System.out.println("余额："+money);
             }
             return number;
         }

     }
    /* public synchronized int getMoney(int number){

             if(number<0){
                 return -1;
             }else if(money<0){
                 return -2;
             }else if(number-money>0){
                 return -3;
             }else {
                 //放在这里是不对的，因为等第一个线程执行完，第二个线程对上面的逻辑并不会进行判断
                 //所以需要考虑清楚需要同步的是哪一个代码块
                 synchronized (this){
                     try {
                         Thread.sleep(1000); //模拟取钱的时间
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     money -= number;
                     System.out.println("余额："+money);
                 }
             }
         return number;
     }*/

 }

使用printChar来模拟线程的同步

Object obj = new Object();
        new Thread() {
            @Override
            public void run() {
                synchronized (obj) {
                    for (int i = 1; i <= 100; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("B");
                        if (i % 4 == 0) {
                            try {
                                obj.wait();//释放锁
                                obj.notify();//唤醒打印AAAAA 的线程
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                synchronized (obj) {
                    for (int i = 1; i <= 100; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("AAAAA");
                        try {
                            obj.notify();//唤醒打印B的线程
                            obj.wait();//释放锁
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }.start();

使用另一个demo来模拟线程的死锁

 package com.iotec.synchronizedTest;

 public class DieThreadDemo {
     public static void main(String[] args) {
         Example example = new Example();
         DieThread1 dieThread1 = new DieThread1(example);
         dieThread1.start();
         DieThread2 dieThread2 = new DieThread2(example);
         dieThread2.start();

     }

 }

 class DieThread1 extends Thread{
     private Example example = null;
     public DieThread1(Example example){
         this.example = example;
     }

     @Override
     public void run() {
         example.method1();
     }
 }
 class DieThread2 extends Thread{
     private Example example = null;
     public DieThread2(Example example){
         this.example = example;
     }

     @Override
     public void run() {
         example.method2();
     }
 }

 class Example{
     private Object obj1 = new Object();
     private Object obj2 = new Object();

     public void method1(){
         synchronized (obj1){
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             synchronized (obj2){
                 System.out.println("method1");
             }
         }
     }
     public void method2(){
         synchronized (obj2){
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             synchronized (obj1){
                 System.out.println("method2s");
             }
         }
     }

 }