synchornized学习笔记

1.对象锁示例同步代码块锁 两个线程同时访问一个方法

    static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance);
        Thread thread2 = new Thread(instance);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()) {

        }
        System.out.println("运行结束");
    }

    @Override
    public void run() {
        synchronized (this) {
            System.out.println("我是对象锁的同步代码块锁" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完毕");
        }
    }

输出结果为:

我是对象锁的方法修饰符形式Thread-0
Thread-0执行完毕
我是对象锁的方法修饰符形式Thread-1
Thread-1执行完毕
运行结束

2.对象锁示例普通方法锁 两个线程同时访问一个方法和上边略有不同

 public static void main(String[] args) {
       Thread thread1 = new Thread(instance);
       Thread thread2 = new Thread(instance);
       thread1.start();
       thread2.start();
       while (thread1.isAlive() || thread2.isAlive()) {

       }
       System.out.println("运行结束");
   }

   @Override
   public void run() {
       Method();
   }

   private  synchronized void Method() {
       System.out.println("我是对象锁的方法修饰符形式" + Thread.currentThread().getName());
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println(Thread.currentThread().getName() + "执行完毕");
   }

输出结果也是和一输出的一样

我是对象锁的方法修饰符形式Thread-0
Thread-0执行完毕
我是对象锁的方法修饰符形式Thread-1
Thread-1执行完毕
运行结束

3类锁 静态方法锁

 static SynchronizedClassstatic instance1=new SynchronizedClassstatic();
   static SynchronizedClassstatic instance2=new SynchronizedClassstatic();

    public static void main(String[] args) {
        Thread thread1=new Thread(instance1);
        Thread thread2=new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()) {

        }
        System.out.println("运行结束");
    }
    @Override
    public void run() {
        Method();
    }
    private static synchronized void Method() {
        System.out.println("我是类锁的第一种形式静态方法" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }

两个线程同时访问了一个静态方法
输出结果为:

我是类锁的第一种形式静态方法Thread-0
Thread-0执行完毕
我是类锁的第一种形式静态方法Thread-1
Thread-1执行完毕
运行结束

可以看到先是Thread0先执行完毕后 Thread1才执行 说明在Thread0没有释放锁的时候Thread1是不能操作的
4类锁的第二种方式 *.class

 static SynchronizedClassClass instance1 = new SynchronizedClassClass();
    static SynchronizedClassClass instance2 = new SynchronizedClassClass();

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()) {

        }
        System.out.println("运行结束");
    }

    @Override
    public void run() {
        Method();
    }

    private void Method() {
        synchronized (SynchronizedClassClass.class) {
            System.out.println("我是对象锁的方法修饰符形式" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完毕");
        }
    }

输出结果为:

我是类锁的第一种形式静态方法Thread-0
Thread-0执行完毕
我是类锁的第一种形式静态方法Thread-1
Thread-1执行完毕
运行结束

结果也显示并没有并行操作
总结:
1.一把锁只能被一个线程获取，没有获取的线程只能等待。

2每个实例都对应的有自己的锁，不同实例之间的锁互不影响。（锁对象是*.class和synchornized 修饰的static静态方法时，所有对象是一把锁）

3无论是方法正常执行还是抛出异常都是会释放锁.

缺点
1 效率低 锁的释放时间少 在试图获取锁的时候无法中断和设置超时时间，
2 不灵活 不能设置加锁和释放的时机
3无法知道是否得到锁
注意点
1.锁对象不能为空 .作用域不能过大. 避免死锁