对象锁和类锁的区别

秒速五厘米 2023-01-13 04:03 224阅读 0赞

### 对实例对象和类加锁的区别 ###

class Account { 
        private int money;
        public Account(int money) { 
            this.money = money;
        }
        public sell(){ }
    }
    Account a = new Account(2000);
    Account b = new Account(2000);

*  实例锁即sycronized(this),加载实例对象上,不同的实例对象之间的锁不冲突.当sell加了sycronized(this),则Account实例对象a和b调用sell(),只需要得到他们各自实例对象的锁,不是同一把锁.
 *  类锁即sycronized(Account.class),加在类对象上.当sell加了sycronized(Account.class),则Account实例对象a和b调用sell(),都需要得到同一把Account类锁
 *  若线程A持有了Account对象锁,线程B又去持有a实例的实例锁,这是允许的并不冲突
 *  以上总结可引申至syncronized修饰实例方法\\代码块\\静态方法,实例方法和代码块加锁的是当前实例对象this,静态方法加锁的是类class.

#### 案例一:卖票 ####

public class ExerciseSell { 
        public static void main(String[] args) { 
            TicketWindow ticketWindow = new TicketWindow(2000);
            List<Thread> list = new ArrayList<>();
            // 用来存储买出去多少张票
            List<Integer> sellCount = new Vector<>();
            for (int i = 0; i < 2000; i++) { 
                Thread t = new Thread(() -> { 
                    // 分析这里的竞态条件
                    int count = ticketWindow.sell(randomAmount());
                    sellCount.add(count);
                });
                list.add(t);
                t.start();
            }
            list.forEach((t) -> { 
                try { 
                    t.join();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            });
            // 买出去的票求和
            log.debug("selled count:{}",sellCount.stream().mapToInt(c -> c).sum());
            // 剩余票数
            log.debug("remainder count:{}", ticketWindow.getCount());
        }
        // Random 为线程安全
        static Random random = new Random();
        // 随机 1~5
        public static int randomAmount() { 
            return random.nextInt(5) + 1;
        }
    }
    
    class TicketWindow { 
        private int count;
        public TicketWindow(int count) { 
            this.count = count;
        }
        public int getCount() { 
            return count;
        }
        public int sell(int amount) { 
            if (this.count >= amount) { 
                this.count -= amount;
                return amount;
            } else { 
                return 0;
            }
        }
    }

**临界区分析**

![image-20210415143148951][]

**解决方法**

![image-20210415143252475][]

因为只涉及TicketWindow ticketWindow = new TicketWindow(2000)这一个TicketWindow实例, 所以在TicketWindow中对sell方法加syncronized, 对成员方法加锁相当于syncronized(this),因此保证了sell方法的线程安全.

#### 案例二:转账 ####

public class ExerciseTransfer { 
        public static void main(String[] args) throws InterruptedException { 
            Account a = new Account(1000);
            Account b = new Account(1000);
            Thread t1 = new Thread(() -> { 
                for (int i = 0; i < 1000; i++) { 
                    a.transfer(b, randomAmount());
                }
            }, "t1");
            Thread t2 = new Thread(() -> { 
                for (int i = 0; i < 1000; i++) { 
                    b.transfer(a, randomAmount());
                }
            }, "t2");
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            // 查看转账2000次后的总金额
            log.debug("total:{}",(a.getMoney() + b.getMoney()));
        }
        // Random 为线程安全
        static Random random = new Random();
        // 随机 1~100
        public static int randomAmount() { 
            return random.nextInt(100) +1;
        }
    }
    class Account { 
        private int money;
        public Account(int money) { 
            this.money = money;
        }
        public int getMoney() { 
            return money;
        }
        public void setMoney(int money) { 
            this.money = money;
        }
        public void transfer(Account target, int amount) { 
            if (this.money > amount) { 
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }

**临界区分析**

涉及到a和b两个实例,transfer会出现线程安全问题

![image-20210415151257849][]  
**解决方法**

1.像案例一一样加在transfer上,相当于加在this,这是对象锁的概念.然而这一题有a和b两个实例对象,他们访问各自的实例锁不冲突,需要将a和b同时加锁,因为转账的时候涉及a和b两个实例的money改变,例如a+1的同时b-1.而a和b对象共享Account类,因此如果对Account类加锁则能解决该问题.

![image-20210415151436293][]

2.加在Account.class上,相当于Account加了锁,无论a实例调用transfer还是b实例调用,都需要获得Account这同一把类锁,保证了线程安全.

![image-20210415151823415][]

[image-20210415143148951]: /images/20221022/58b87b5a04f84982a022060c13f50267.png
[image-20210415143252475]: /images/20221022/eddcece567f8444297f9521fda565fe4.png
[image-20210415151257849]: /images/20221022/6fa316ed084645008905e21bcf1870da.png
[image-20210415151436293]: /images/20221022/cff674ffe6cd4963a72e12ec4d5c798a.png
[image-20210415151823415]: /images/20221022/49e90024355d4271a433043764764471.png