本文主要向大家介绍了JAVA语言多线程之Synchronized、wait、notify实例讲解，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

一、Synchronized

synchronized中文解释是同步，那么什么是同步呢，解释就是程序中用于控制不同线程间操作发生相对顺序的机制，通俗来讲就是2点，第一要有多线程，第二当多个线程同时竞争某个资源的时候会有先后顺序。在java中有三种写synchronized的方式：

第一种：写在普通方法的前面，这种表示对实例对象加锁第二种：写在静态方法前面，这种表示对类对象加锁第三种：写在代码块中，锁是Synchonized括号里配置的对象（可能是实例对象，也可能是类对象）

总体说来就2种，一种就是锁实例对象，一种锁类对象。

锁实例对象就是当多个线程同时操作这个实例对象（针对的是特定的实例对象）的时候必须先获取锁，如果无法获取锁，则必须处于等待状态，而和锁类对象区别是，当多个线程同时操作的时候，任何以这个类对象实例化的对象都要获取锁才能操作。

看下面的例子：

public class Synchronized_Test {

    public static void main(String[] args){

        Thread t1=new Thread(new MyRunnable());

        Thread t2=new Thread(new MyRunnable());

        t1.start();

        t2.start();

    }

}

class MyRunnable implements Runnable{

    private synchronized void synchMethodTest(){

        for(int i=0;i<10;i++)

            System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);

    }

    public void run() {

        synchMethodTest();

    }

}

其输出结果为：

Thread-0synchMethodTest: 0

Thread-1synchMethodTest: 0

Thread-0synchMethodTest: 1

Thread-1synchMethodTest: 1

Thread-0synchMethodTest: 2

Thread-1synchMethodTest: 2

Thread-0synchMethodTest: 3

Thread-1synchMethodTest: 3

Thread-0synchMethodTest: 4

Thread-1synchMethodTest: 4

Thread-0synchMethodTest: 5

Thread-1synchMethodTest: 5

Thread-0synchMethodTest: 6

Thread-1synchMethodTest: 6

Thread-0synchMethodTest: 7

Thread-1synchMethodTest: 7

Thread-0synchMethodTest: 8

Thread-1synchMethodTest: 8

Thread-0synchMethodTest: 9

Thread-1synchMethodTest: 9

因为synchronized是写在普通方法前，是对特定的实例对象加锁，t1，t2为两个不同的实例，所以他们在执行synchronized方法时并不会互相阻塞对方。

如果将synchronized方法改成static方法，那么就是针对类对象加锁，任何以这个类对象实例化的对象都要获取锁才能操作，t1，t2虽然是两个不同的实例，但都是同一个类对象的实例，所以当t1取得锁开始执行synchronized方法后，就会阻塞t2，t2需要取得锁之后才能执行，如下：

public class Synchronized_Test {

    public static void main(String[] args){

        Thread t1=new Thread(new MyRunnable());

        Thread t2=new Thread(new MyRunnable());

        t1.start();

        t2.start();

    }

}

class MyRunnable implements Runnable{

    private synchronized static void synchMethodTest(){

        for(int i=0;i<10;i++)

            System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);

    }

    public void run() {

        synchMethodTest();

    }

}

输出结果为：

Thread-0synchMethodTest: 0

Thread-0synchMethodTest: 1

Thread-0synchMethodTest: 2

Thread-0synchMethodTest: 3

Thread-0synchMethodTest: 4

Thread-0synchMethodTest: 5

Thread-0synchMethodTest: 6

Thread-0synchMethodTest: 7

Thread-0synchMethodTest: 8

Thread-0synchMethodTest: 9

Thread-1synchMethodTest: 0

Thread-1synchMethodTest: 1

Thread-1synchMethodTest: 2

Thread-1synchMethodTest: 3

Thread-1synchMethodTest: 4

Thread-1synchMethodTest: 5

Thread-1synchMethodTest: 6

Thread-1synchMethodTest: 7

Thread-1synchMethodTest: 8

Thread-1synchMethodTest: 9

t1执行完成，释放synchronized锁后，t2才能执行。如果在代码块中对类对象也是一样：

class MyRunnable implements Runnable{

    private void synchMethodTest(){

        synchronized (MyRunnable.class){

            for(int i=0;i<10;i++)

                System.out.println(Thread.currentThread().getName()+"synchMethodTest: "+i);

        }

    }

    public void run() {

        synchMethodTest();

    }

}

注意：

类方法中，synchronized锁住的是对象this,只有调用同一个对象的方法才需要获取锁。同时，同一个对象中所有加了synchronize的方法只能一次调用一个；

静态方法中，synchronized锁的是整个类对象，类似于(X.class)，该类中所有加了synchronized的静态方法，一次只能调用一个。

比较下面两个例子：

public class Synchronized_Test {

    public static void main(String[] args){

        Method method=new Method();

        Thread t1=new Thread(new MyRunnable1(method));

        Thread t2=new Thread(new MyRunnable2(method));

        t1.start();

        t2.start();

    }

}

class Method{

    public synchronized void Method1(){

        for(int i=0;i<10;i++)

            System.out.println(Thread.currentThread().getName()+" Method1: "+i);

    }

    public synchronized void Method2(){

        for(int i=0;i<10;i++)

            System.out.println(Thread.currentThread().getName()+" Method2 "+i);

    }

}

class MyRunnable1 implements Runnable{

    Method method;

    MyRunnable1(Method method){

        this.method=method;

    }

    public void run() {

        method.Method1();

    }

}

class MyRunnable2 implements Runnable{

    Method method;

    MyRunnable2(Method method){

        this.method=method;

    }

    public void run(){

        method.Method2();

    }

}

输出为：

Thread-0 Method1: 0

Thread-0 Method1: 1

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！