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.锁对象不能为空 .作用域不能过大. 避免死锁

synchornized学习笔记

推荐阅读更多精彩内容