java多线程（四）synchronized关键字修饰方法

转载请注明出处：http://blog.csdn.net/xingjiarong/article/details/47907237

在之前的博客中我们介绍了条件对象和锁对象，两者结合使用才能起到比较好的互斥与同步效果，大家可能觉得有些麻烦，有没有将两者结合起来的工具呢，有！java提供了synchronized关键字来实现线程的互斥和同步，其达到的效果相当于条件对象和锁对象结合起来的效果。synchronized关键字有两类用法，一类是修饰方法，一类是修饰代码块，这篇博客主要介绍一下synchronized关键字修饰方法时的用法。

先来为大家介绍一下java中锁的概念。java中的每个对象和每个类都有锁，而且是互斥锁，也就是说只能有一方占有，另一方只能等到对方释放后才能再占有锁。synchronized关键字就是基于java的对象和类的锁的。

一、修饰普通方法

下面来看一下下面这个例子，Trans这个类是在一行中打印当前的线程和0-24这25个数。MyThread这个类接收一个Trans类的对象，在run方法中不停的调用printNum方法。在main方法中，创建了一个对象和两个线程，这两个线程都使用同一个Trans对象。

public class Trans {

    public void printNum(int num){
        System.out.print(Thread.currentThread());//获取当前运行这个方法的类
        for(int i=0;i<25;i++){
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

class MyThread implements Runnable {
    private Trans trans;
    private int num;

    public MyThread(Trans trans, int num) {
        this.trans = trans;
        this.num = num;
    }

    public void run() {
        while (true)
        {
            trans.printNum(num);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class Test {


    public static void main(String[] args) {

        Trans t = new Trans();
        Thread a = new Thread(new MyThread(t, 1));
        Thread b = new Thread(new MyThread(t, 2));

        a.start();
        b.start();

    }

}

现在，两个线程会同时执行Trans的printNum方法，因为又是同一个对象的方法，所以一定会产生RaceCondition，我的结果如下：

可以看到，打印结果确实是不正确的。那么怎么用synchronized关键字避免这种情况呢？可以将printNum方法的声明改为下面这种：

public synchronized void printNum(int num){
        System.out.print(Thread.currentThread());
        for(int i=0;i<25;i++){
            System.out.print(i+" ");
        }
        System.out.println();
    }

这就是用synchronized关键字修饰方法，现在我们再来试一下程序，看看还会不会产生RaceCondition。果然不会再产生RaceCondition了，是不是比用条件锁方便多了，那么为什么这样就可以了呢？我们来分析一下：之前我们说过，synchronized关键字会获得锁，所以在这里synchronized关键字获得的锁就是传递给线程的那个Trans对象的锁，两个线程用的是同一个锁，所以当一个线程执行到synchronized修饰的方法时，这个线程就会获得Trans对象的锁，并且这个锁是互斥的，所以其他试图想要获得锁的线程都必须等待，直到这个线程释放了锁，从而起到了互斥的作用。

每个对象都有自己的锁，所以这里synchronized关键字起作用的原因就是因为两个线程用的是同一个对象，如果每个线程都有自己的Trans对象，那么上边的方法将不再适用，例如我们把Main方法改为下面这样：

public static void main(String[] args) {

        Trans t = new Trans();
        Trans t1 = new Trans();
        Thread a = new Thread(new MyThread(t, 1));
        Thread b = new Thread(new MyThread(t1, 2));

        a.start();
        b.start();

    }

这里每个线程都有自己的Trans对象，每个线程获得的锁也是自己对象的锁，两个锁之间互不干扰，所以synchronized关键字不会起到作用，那么这时应该怎么用synchronized关键字呢？那就是使用synchronized关键字修饰代码块，这种用法我们下篇博客再讲，这篇先把synchronized关键字修饰方法的用法讲清楚。

既然每个对象都只有一把互斥锁，那么同一个对象的多个synchronized关键字修饰的方法之间也是无法同时访问的。例如下面的例子：

public class Trans {

    public synchronized void printNum(int num) {
        while (true) {
            System.out.print(Thread.currentThread());
            for (int i = 0; i < 25; i++) {
                System.out.print(i + " ");
            }
            System.out.println();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public synchronized void printNum1(int num) {
        System.out.print(Thread.currentThread());
        for (int i = 25; i > 0; i--) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public void printNum2(int num) {
        for (int i = 25; i > 0; i--) {
            System.out.print(num);
        }
        System.out.println();
    }
}

[java]  view plain              System.out.print(num);  

        }  

        System.out.println();  

    }  

}  

class MyThread implements Runnable {
    private Trans trans;
    private int num;

    public MyThread(Trans trans, int num) {
        this.trans = trans;
        this.num = num;
    }
   
         
             }
}

class MyThread implements Runnable {
    private Trans trans;
    private int num;

    public MyThread(Trans trans, int num) {
        this.trans = trans;
        this.num = num;
    }

  &:16px;height:16px;">

1. class MyThread