多线程编程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");
            }
        }
    }

}