并发编程 | 类锁和对象锁

尚硅谷并发编程课p31 p32

本文为视频笔记，仅供自用，且内容不一定都对

类锁对象锁的概念

• 类锁：被static sync 修饰的方法持有类锁；sync代码块括号内是类的也持有类锁
• 对象锁：仅被sync修饰的方法持有对象锁

效果和影响

• 同一个类里，所有被static sync 修饰的方法都是竞态的。即a方法在执行，b方法就不能执行，除非a用同步对象主动让出了锁（await方法）
• 同一个类里，所有被sync 修饰的、且被同一个对象调用的方法都是竞态的。即a方法在执行，b方法就不能执行，除非a用同步对象主动让出了锁
• 同一个类里，被static sync 修饰的方法、仅被sync 修饰的方法，不是竞态的

多线程执行效果的影响因素

1. 可以把方法设置得更耗时一些。被执行方法的耗时太短，会导致demo体现不出时间片是被多个线程竞争的
2. 可以把demo多运行几遍，因为线程的执行顺序和start的顺序无关，谁被分配到时间片谁就先执行
3. 通常我们将某个线程设置成sleep的时间长一点，是为了让其他线程有更多的机会参与时间片竞争。在写demo调试时可以多使用这些技巧。或者调整线程的优先级也行

值得思考的问题

• 锁的释放条件
• 子线程之间是按照代码顺序执行的吗（就是是否谁先start谁就先执行）
• 哪些暂停方法是可以让出锁的
• 无锁开发指的是

总结

demo

一个体现类锁和对象锁不是竞态的demo

package com.example.juc;

import java.util.concurrent.TimeUnit;

// 模拟对象锁和类锁; 假设有线程并发访问Message
public class Message {

    // 类锁 （锁了类，所有由这个类产生的对象方法都参与竞争bushi  应该是需要持有类锁的方法都会参与竞争）
    private static synchronized void a() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(100);  // 赌其他线程能在这段时间内抢到时间片
        for (int i = 0; i < 10000; i++) {
            System.out.println("aaaaaaaaaaa" + i);
        }
    }

    // 对象锁 （锁了对象，仅单个特定对象方法参与竞争）
    private synchronized void b() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("b" + i);
        }
    }

    private void c() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("zzz" + i);
        }
    }

    public static void main(String[] args) {

        // 类锁和对象锁有冲突吗，是非竞争态的吧
        Message message = new Message();

        new Thread(()->{
            try {
                message.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            message.b();
        }).start();

        new Thread(() -> {
            message.c();
        }).start();

    }

}

自己对锁的理解

之前一直不懂锁是啥。后面抽象理解了一下，可以把加锁的操作理解为给一个key set 1。
key为1时即代表已上锁