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

最新推荐文章于 2024-07-11 23:19:16 发布

xingjiarong

最新推荐文章于 2024-07-11 23:19:16 发布

阅读量1.4w

点赞数 16

分类专栏： java java多线程文章标签： java 多线程线程

本文链接：https://blog.csdn.net/xingjiarong/article/details/47907237

版权

java 同时被 2 个专栏收录

16 篇文章 2 订阅

订阅专栏

java多线程

9 篇文章 15 订阅

订阅专栏

转载请注明出处：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();
	}
}

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() {
		trans.printNum(num);
	}
}

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

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

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

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

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

	public void run() {
		while (true) {
			trans.printNum2(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 MyThread1(t, 2));
		Thread c = new Thread(new MyThread2(t, 2));

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

	}

}

首先，Trans类增加了两个方法，一个方法其中一个方法也是用synchronized关键字修饰的方法，另一个方法是不用synchronized关键字修饰的，在Main方法中创建了三个线程，这个三个线程都是同一个Trans对象，分别调用三个不同的打印方法。第一个打印方法是一个死循环，一直在打印信息，又是synchronized修饰的方法，一旦获得了对象的锁就不会释放了，第二个方法也是synchronized关键字修饰的方法，这两个方法不能同时执行，如果第一个方法获得了锁，那么第二个方法将永远不能执行，第三个打印方法不是synchronized的，所以锁对它没有任何的影响，可以随时的执行。

下面是我的执行结果：

和我们想的一样，方法一和方法三交替执行，方法二不会执行。

二、修饰静态方法

我们知道静态方法被整个类拥有，所有的类的对象共用这一个方法，那么synchronized关键字修饰static方法所获得的锁是这个类的锁，而不是这个对象的锁。那么一个类的锁和一个类的对象的锁有什么关系呢？

每个类都有一个互斥锁，每个类可能会有多个不同的对象，每个对象都有一个它自己的对象锁。自然，类的锁的管辖范围比对象的锁的管辖范围大，不同的对象之间的锁互不影响，但是他们都受类的锁的控制，如果一个类的锁被一个线程获得，那么这个类的所有的对象都不能访问需要获得类的锁的方法，但是可以访问不需要锁的方法和需要某个对象锁的方法。

例如下面这个例子，就可以很好的说明，static方法被synchronized修饰时，这个类的所有的对象都是锁的影响。

public class Trans {

	public static synchronized 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();  
        Trans t1 = new Trans();  
        Thread a = new Thread(new MyThread(t, 1));  
        Thread b = new Thread(new MyThread(t1, 2));  
  
        a.start();  
        b.start();  
  
    }  
  
}

一个线程访问static的synchronized方法时，其他的线程还可以访问不是static却被synchronized修饰的方法，例如：

public class Trans {

	public static synchronized void printNum(int num){  
        System.out.print(Thread.currentThread());  
        for(int i=0;i<25;i++){  
            System.out.print(i+" ");  
        }  
        System.out.println();  
    }
	
	public synchronized void printNum1(int num){  
        System.out.print(Thread.currentThread());  
        for(int i=0;i<25;i++){  
            System.out.print(2+" ");  
        }  
        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();  
            }  
        }  
              
    }  
}  

class MyThread1 implements Runnable {  
    private Trans trans;  
    private int num;  
  
    public MyThread1(Trans trans, int num) {  
        this.trans = trans;  
        this.num = num;  
    }  
  
    public void run() {  
        while (true)  
        {  
            trans.printNum1(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 MyThread1(t, 2));  
  
        a.start();  
        b.start();  
  
    }  
  
}

了解了锁的概念和synchronized修饰方法的用法之后我们可以总结出，两个方法是不是互斥的关键是看两个方法取得的锁是不是互斥的，如果锁是互斥的，那么方法也是互斥访问的，如果锁不是互斥的，那么不同的锁之间是不会有什么影响的，所以这时方法是可以同时访问的。