[java多线程]多线程同步(一)——synchronized

最新推荐文章于 2023-09-05 12:05:51 发布

cq1982

最新推荐文章于 2023-09-05 12:05:51 发布

阅读量709

点赞数 2

分类专栏：后端技术文章标签：多线程 java

本文链接：https://blog.csdn.net/cq1982/article/details/38783147

版权

后端技术专栏收录该内容

90 篇文章 0 订阅

订阅专栏

一、synchronized修饰方法

synchronized关键字可以用来修饰并保护我们在类中定义的方法，保证在某一时刻某个方法只有一个线程能访问，

对于普通成员方法，synchronized实际上是对这个类的某个对象实例加锁，等效于synchronized(this){...}。

1、一个方法同步无效的例子

线程类定义：

/**
 * 这里我们在run()方法中加入了synchronized关键字，希望能对run方法进行互斥访问，但结果并不如我们希望那样，
 * 这是因为这里synchronized锁住的是this对象，即当前运行线程对象本身。
 * 代码中创建了3个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。
 */
public class MyThread implements Runnable {
	private int threadId;

	public MyThread(int id) {
		this.threadId = id;
	}

	@Override
	public synchronized void run() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", Thread ID: " + this.threadId + ", i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

测试类定义：

public class Test {

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 3; ++i) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		}
	}

}

执行结果可以看到，三个线程还是在并发的执行，并没有因为run()方法加了synchronized修饰就同步了，

原因自然就是synchronized普通方法实际上是对对象自身的this加锁，三个线程是三个独立的对象，有三个不同的this，锁当然就无效了。

2、修饰普通方法

2.1. 还是用synchronized修饰run()方法

线程类定义：

public class MyThread implements Runnable {

	@Override
	public synchronized void run() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

看到和刚才的线程并没有什么不同，仍然是对run()方法加锁；

测试类定义：

public class Test {

	public static void main(String[] args) throws InterruptedException {
		MyThread myThread = new MyThread();
		for (int i = 0; i < 3; ++i) {
			new Thread(myThread).start();
			Thread.sleep(1);
		}
	}

}

执行结果是一个线程的run()方法执行完毕，下一个线程的run()方法才会执行，

因为三个线程都共用一个myThread对象，加锁的对象是同一个this，自然就能正确同步了。

2.2. 用synchronized修饰其它方法

线程类定义：

public class MyThread implements Runnable {

	@Override
	public void run() {
		otherMethodOne();
		otherMethodTwo();
	}

	private synchronized void otherMethodOne() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", otherMethodOne, i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	private synchronized void otherMethodTwo() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", otherMethodTwo, i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

我们看到，run()方法调用另外两个同步方法otherMethodOne()和otherMethodTwo()，每个其它同步方法内部将循环打印几次，

测试类定义：

public class Test {

	public static void main(String[] args) throws InterruptedException {
		MyThread myThread = new MyThread();
		for (int i = 0; i < 3; ++i) {
			new Thread(myThread).start();
			Thread.sleep(1);
		}
	}

}

执行结果显示，一个线程的run()方法一个同步方法执行完毕，不一定紧接着执行第二个同步方法，而很有可能执行其他线程的某个同步方法，

但同步方法执行的时候，不会同时执行别的同步方法的打印语句，
可见，只对synchronized修饰的方法内部实现加锁，同步方法执行完毕之后，锁就被释放，其它线程也就有机会竞争得到这个锁；

但如果测试类如下方式执行线程：

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 3; ++i) {
        new Thread(new MyThread()).start();
        Thread.sleep(1);
    }
}

可想而知，同步又会失效……

3、修饰静态方法

对于静态成员方法，synchronized实际上是对这个类加锁，等效于synchronized(ClassName.class){...}。

线程类定义：

public class MyThread implements Runnable {
	private int threadId;

	public MyThread(int id) {
		this.threadId = id;
	}

	@Override
	public void run() {
		otherMethodOne(this.threadId);
		otherMethodTwo(this.threadId);
	}

	private static synchronized void otherMethodOne(int threadId) {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", Thread ID: " + threadId + ", otherMethodOne, i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	private static synchronized void otherMethodTwo(int threadId) {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			System.out.println("threadName: " + threadName + ", Thread ID: " + threadId + ", otherMethodTwo, i: " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

说明：run()方法可不能static...所以我们将其他方法变成静态方法；

测试类定义：

public class Test {

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 3; ++i) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		}
	}

}

说明：

这里是三个独立的MyThread对象，执行结果可以看到一个静态方法执行完毕，另外的静态方法才会执行，

没有用下面的形式，之前就讨论过了，还用得着静态方法么？费那事干嘛……

MyThread myThread = new MyThread(...);
for (int i = 0; i < 3; ++i) {
    new Thread(myThread).start();
    Thread.sleep(1);
}

二、synchronized修饰成员对象

1、修饰基本数据类型，行不行？

看下面的线程类定义：

显然在编译时就会提示不行了，

对于这种情况我们可以用基本数据类型对应的包装类，比如这里把变量num换成Integer类型的就可以了，编译就不报错了，

但是真的就可以按照我们预想的执行么？我们接着往下看...

2、修饰普通成员对象

修饰普通成员对象，synchronized对这个成员对象加锁。

2.1. 我们用Integer对象来试试

线程类定义：

public class MyThread implements Runnable {

	private Integer num; // int is not work...

	public MyThread(Integer num) {
		this.num = num;
	}

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			synchronized (num) {
				System.out.println("threadName: " + threadName + ", num: " + num++);
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}

测试类定义：

public class Test {

	public static void main(String[] args) throws InterruptedException {
		MyThread myThread = new MyThread(0);
		for (int i = 0; i < 3; ++i) {
			new Thread(myThread).start();
			Thread.sleep(1);
		}
	}
}

从执行结果可以看到num变量是原子的方式增加的，num从0增长到14，没有发生混乱；

那换成下面这样的测试类定义呢？

public static void main(String[] args) throws InterruptedException {
	for (int i = 0; i < 3; ++i) {
		new Thread(new MyThread(0)).start();
		Thread.sleep(1);
	}
}

执行结果每个线程中num都从0开始自增，显然这个不是我们想看到的，

调用类的构造方法时，直接赋值成0不行，那我们换成下面这样的测试类定义呢？

public static void main(String[] args) throws InterruptedException {
	Integer num = new Integer(0);
	for (int i = 0; i < 3; ++i) {
		new Thread(new MyThread(num)).start();
		Thread.sleep(1);
	}
}

还是一样，执行结果每个线程中num都从0开始自增，为什么不行呢？

有网上的朋友给出这样的解释，转帖过来：
对于
Integer j = new Integer(10);

j++等同于j = new Integer(j + 1);
用下面的代码可以证明上面的结论：

Integer j = new Integer(10);
// Different hash code will be printed.
System.out.println(System.identityHashCode(j));
j++;
System.out.println(System.identityHashCode(j));
j = new Integer(j + 1);
System.out.println(System.identityHashCode(j));

2.2. 我们用自定义的bean来试试

自定义bean如下：

public class MyBean {
	int num;

	public MyBean(int num) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

}

线程类定义：

public class MyThread implements Runnable {

	private MyBean bean;

	public MyThread(MyBean bean) {
		this.bean = bean;
	}

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			synchronized (bean) {
				int num = bean.getNum();
				System.out.println("threadName: " + threadName + ", num: " + num);
				bean.setNum(num + 1);
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}

测试类定义：

public class Test {
	public static void main(String[] args) throws InterruptedException {
		MyBean bean = new MyBean(0);
		for (int i = 0; i < 3; ++i) {
			new Thread(new MyThread(bean)).start();
			Thread.sleep(1);
		}
	}
}

执行结果可以看出，bean中的num从0增长到14，我们想要的共享和同步的效果就是这样。

3、修饰静态对象

修饰静态成员对象，synchronized对这个静态成员对象加锁，

因为java的同一个类的多个对象共用同一个静态成员对象，所以能保证多线程同步的正常工作。

还是刚才的bean定义：

public class MyBean {
	int num;

	public MyBean(int num) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

}

线程类定义：

public class MyThread implements Runnable {

	private static MyBean bean = new MyBean(0);

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		for (int i = 0; i < 5; i++) {
			synchronized (bean) {
				int num = bean.getNum();
				System.out.println("threadName: " + threadName + ", num: " + num);
				bean.setNum(num + 1);
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}

测试类定义：

public class Test {
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 3; ++i) {
			new Thread(new MyThread()).start();
			Thread.sleep(1);
		}
	}
}

从执行结果可以看到bean中的num从0增长到14。,