多线程编程-synchronized

  1 package com.iotec.synchronizedTest;
  2 
  3 import java.io.ObjectInputStream;
  4 
  5 public class BankDemo {
  6     public static void main(String[] args) {
  7         Bank bank = new Bank();
  8         BankThread p1 = new BankThread(bank);
  9         p1.start();     //柜台取钱
 10         BankThread p2 = new BankThread(bank);
 11         p2.start();     //ATM机上取钱
 12 
 13     }
 14 }
 15 
 16 class BankThread extends Thread{
 17     private Bank bank = null;
 18     public BankThread(Bank bank){
 19         this.bank = bank;
 20     }
 21 
 22     @Override
 23     public void run() {
 24         System.out.println(Thread.currentThread().getName()+"取钱："+bank.getMoney(400));
 25     }
 26 }
 27 
 28 class Bank {
 29     //把竞争访问的资源标识为private
 30     private int money = 500;
 31 
 32     private Object object = new Object();
 33     //取钱的方法，返回取钱的数目
 34     //当一个线程去调用同步方法的时候，这个线程就获得当前对象的锁
 35     //其它线程当调用同步方法的时候只能等待，因为无法获取对象的锁
 36     //只有第一个线程释放对象的锁方可进入
 37 /*    public synchronized int getMoney(int number){
 38         if(number<0){
 39             return -1;
 40         }else if(money<0){
 41             return -2;
 42         }else if(number-money>0){
 43             return -3;
 44         }else {
 45             try {
 46                 Thread.sleep(1000); //模拟取钱的时间
 47             } catch (InterruptedException e) {
 48                 e.printStackTrace();
 49             }
 50             money -= number;
 51             System.out.println("余额："+money);
 52         }
 53         return number;
 54     }*/
 55     public synchronized int getMoney(int number){
 56 //        synchronized (this){
 57         //可以持有的是任何对象
 58         synchronized (object){
 59             if(number<0){
 60                 return -1;
 61             }else if(money<0){
 62                 return -2;
 63             }else if(number-money>0){
 64                 return -3;
 65             }else {
 66                 try {
 67                     Thread.sleep(1000); //模拟取钱的时间
 68                 } catch (InterruptedException e) {
 69                     e.printStackTrace();
 70                 }
 71                 money -= number;
 72                 System.out.println("余额："+money);
 73             }
 74             return number;
 75         }
 76 
 77     }
 78    /* public synchronized int getMoney(int number){
 79 
 80             if(number<0){
 81                 return -1;
 82             }else if(money<0){
 83                 return -2;
 84             }else if(number-money>0){
 85                 return -3;
 86             }else {
 87                 //放在这里是不对的，因为等第一个线程执行完，第二个线程对上面的逻辑并不会进行判断
 88                 //所以需要考虑清楚需要同步的是哪一个代码块
 89                 synchronized (this){
 90                     try {
 91                         Thread.sleep(1000); //模拟取钱的时间
 92                     } catch (InterruptedException e) {
 93                         e.printStackTrace();
 94                     }
 95                     money -= number;
 96                     System.out.println("余额："+money);
 97                 }
 98             }
 99         return number;
100     }*/
101 
102 }

 1 package com.iotec.synchronizedTest;
 2 
 3 public class DieThreadDemo {
 4     public static void main(String[] args) {
 5         Example example = new Example();
 6         DieThread1 dieThread1 = new DieThread1(example);
 7         dieThread1.start();
 8         DieThread2 dieThread2 = new DieThread2(example);
 9         dieThread2.start();
10 
11     }
12 
13 }
14 
15 class DieThread1 extends Thread{
16     private Example example = null;
17     public DieThread1(Example example){
18         this.example = example;
19     }
20 
21     @Override
22     public void run() {
23         example.method1();
24     }
25 }
26 class DieThread2 extends Thread{
27     private Example example = null;
28     public DieThread2(Example example){
29         this.example = example;
30     }
31 
32     @Override
33     public void run() {
34         example.method2();
35     }
36 }
37 
38 class Example{
39     private Object obj1 = new Object();
40     private Object obj2 = new Object();
41 
42     public void method1(){
43         synchronized (obj1){
44             try {
45                 Thread.sleep(1000);
46             } catch (InterruptedException e) {
47                 e.printStackTrace();
48             }
49             synchronized (obj2){
50                 System.out.println("method1");
51             }
52         }
53     }
54     public void method2(){
55         synchronized (obj2){
56             try {
57                 Thread.sleep(1000);
58             } catch (InterruptedException e) {
59                 e.printStackTrace();
60             }
61             synchronized (obj1){
62                 System.out.println("method2s");
63             }
64         }
65     }
66 
67 }