java多线程学习笔记（六）

本节开始synchronized关键字的最后一部分内容：

静态同步方法synchronized方法与synchronized(class)代码块

关键字synchronized还可以用在static静态方法上，如果这样写，相当于对当前的*.java文件对应的Class类进行持锁。

结论写在前面：synchronized加到静态方法上和加到非静态方法上表面上的使用效果是一样的，但本质效果不同，synchronized关键字加到static静态方法上是给Class类加锁，而synchronized关键字加到非静态方法上是给对象加锁，两者不是同一个锁，所以同时使用的时候，当两个线程分表调用两种方法时，会出现异步的效果；

同步synchronized(class)代码块的作用其实是和synchronized static方法的作用是一样的

同步方法容易造成死循环，有案例如下：

public class Service {

  synchronized  public void methodA(){

      System.out.println("methodA begin");

      boolean isContinueRun = true;

      while (isContinueRun) {

      }

      System.out.println("methodA end");

  }

  synchronized  public void methodB(){

      System.out.println("methodB begin");

      System.out.println("methodB end");

  }

}

public class ThreadA extends  Thread{

    private Service service;

    public ThreadA(Service service) {

        this.service = service;

    }

    @Override

    public void run() {

        super.run();

        service.methodA();

    }

}

public class ThreadB extends  Thread{

    private Service service;

    public ThreadB(Service service) {

        this.service = service;

    }

    @Override

    public void run() {

        super.run();

        service.methodB();

    }

}

public class Test {

    public static void main(String[] args) {

        Service service = new Service();

        ThreadA threadA = new ThreadA(service);

        threadA.setName("a");

        threadA.start();

        ThreadB threadB = new ThreadB(service);

        threadB.setName("b");

        threadB.start();

    }

}

直接使用对象锁，会导致线程无限等待，但是如果使用synchronized代码块的话，有如下的改进：

public class Service {

    Object object1 = new Object();

    public void methodA(){

        synchronized (object1) {

            System.out.println("methodA begin");

            boolean isContinueRun = true;

            while (isContinueRun) {

            }

            System.out.println("methodA end");

        }

  }

    Object object2 = new Object();

    public void methodB(){

        synchronized (object2) {

            System.out.println("methodB begin");

            System.out.println("methodB end");

        }

  }

}

这样的话就不会出现同步等待的状况，因为 methodA 和 methodB 是可以异步调用的。

内置类与静态内置类

我们首先看看内置类和静态内枝类的区别，其实我们光从这个名字还不太容易高明白，下面是截取的网上的，理解起来还容易一点。

从字面上看，一个被称为静态嵌套类，一个被称为内部类。从字面的角度解释是这样的：什么是嵌套？嵌套就是我跟你没关系，自己可以完全独立存在，但是我就想借你的壳用一下，来隐藏一下我自己。什么是内部？内部就是我是你的一部分，我了解你，我知道你的全部，没有你就没有我。（所以内部类对象是以外部类对象存在为前提的）

public class Test190 {

    class  inner{

        public void show() {

            System.out.println("这是内部类");

        }

    }

    static class staticinner{

        public void show1() {

            System.out.println("这是静态内部类");

        }

    }

    public static void main(String[] args) {

        Test190 t = new Test190();

        inner i = t. new inner();

        staticinner si  =new staticinner();

        i.show();

        si.show1();

    }

}

巴特西

java多线程学习笔记（六）

静态同步方法synchronized方法与synchronized(class)代码块

内置类与静态内置类

最新文章

热门文章