Java中synchronized的基本使用

纯洁的代码
152 阅读6分钟
synchronized
synchronized
是一个同步锁关键字，作用就是让线程只能逐一执行，不能并行执行，至于底层怎么实现，不是我这种连用都不会的人改关注的。
用法
– 修饰代码快（非静态）
测试代码（不加
synchronized
）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new SynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
teacher.say(name);
}
}
static class Teacher {
public void say(String name) {
System.out.println("
我正在教
" + name);
//System.out.println("
线程进入睡眠
");
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
}
执行结果：
我正在教
first
我正在教
second
second
睡眠三秒
first
睡眠三秒
两个睡眠三秒几乎是同时出现。
测试代码（加
synchronized
）：
static class Teacher {
public void say(String name) {
System.out.println("
我正在教
" + name);
synchronized (this) {
//System.out.println("
线程进入睡眠
");
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
}
输出结果：
我正在教
first
我正在教
second
first
睡眠三秒
second
睡眠三秒
虽然看着是一样的，实际输出的时候，是先输出一个睡眠三秒，
3
秒之后，再输出一个睡眠三秒。
总结：在多个线程操作同一个对象，执行加锁的对象方法的时候，逐一执行同步代码块中的代码，锁的是对象实例
– 修饰对象方法
测试代码（加
synchronized
）：
static class Teacher {
public synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
执行结果：
我正在教
first
first
睡眠三秒
我正在教
second
second
睡眠三秒
可以看到输出结果是先是一个线程（
first
）执行了方法，然后是另外一个线程（
second
）执行了方法。
测试代码（不加
synchronized
）：
static class Teacher {
public void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
执行结果：
我正在教
first
我正在教
second
second
睡眠三秒
first
睡眠三秒
可以看到两个线程几乎同时执行了，这和外汇返佣
http://www.fx61.com/
代码块的测试是一样的结果。
测试代码（一个方法不加
synchronized
，一个方法加
synchronized
）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
teacher.hello(name);
}
}
static class Teacher {
public synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
public void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
}
执行结果：
我正在教
first
我会说
hello
hello second
first
睡眠三秒
可以看到，多线线程执行同一个对象的同步方法和非同步方法的时候，两个方法的执行相互不影响。
测试代码（一个方法加
synchronized
，另外一个方法也加
synchronized
）：
static class Teacher {
public synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
public synchronized void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
执行结果：
我正在教
first
first
睡眠三秒
我会说
hello
hello second
虽然结果不能明显看出输出顺序，但是执行时我能看到是先执行一个方法，执行完之后再执行另外一个方法。
测试代码（一个静态方法不加
synchronized
，一个对象方法加
synchronized
）：
public class Synchronized {
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
Teacher.hello(name);
}
}
static class Teacher {
public synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
public static void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
}
执行结果：
我正在教
first
我会说
hello
hello second
first
睡眠三秒
从结果上可以看到，对象方法上加同步对静态方法没有影响。
另外静态方法加上了
synchronized
，两个方法的执行之间也不影响。
总结：
1
、首先静态方法加不加同步，对实例方法没什么影响；
2
、加同步的实例方法，对不加同步的实例方法没什么影响；
3
、只有都是实例方法并且都加同步的情况下，才会出现同步逐一执行的效果；
静态方法
– 静态方法
上面已经知道了对象方法加同步，对静态方法没有影响。
测试代码（两个静态方法加
synchronized
）：
static class Teacher {
public static synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
public static synchronized void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
执行结果：
我正在教
first
first
睡眠三秒
我会说
hello
hello second
可以看到，是先执行了一个方法，再执行另外一个方法。
测试代码（一个静态方法加
synchronized
，一个静态方法不加
synchronized
）：
static class Teacher {
public static synchronized void say(String name) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
public static void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
执行结果：
我正在教
first
我会说
hello
hello second
first
睡眠三秒
两个方法的执行没有影响。
总结：静态方法方法加同步只对加了同步的静态方法有影响。
以上都是常规的写法，实例方法给对象实例枷锁，静态方法给类枷锁。还有一些其它的写法。
其它写法
测试代码（在实例方法上加
synchronized
，加锁的是类）：
static class Teacher {
public static void say(String name) {
synchronized(Teacher.class) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
public static synchronized void hello(String name) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
执行结果：
我正在教
first
first
睡眠三秒
我会说
hello
hello second
执行效果，类似与两个加了同步的静态方法，这种写法是给类加锁，所有需要同步类的方法都会受影响。
测试代码（定义一个类变量（是一个对象），用来同步）：
public class Synchronized {
private static Test lock = new Test();
public static void main (String[] args) {
Teacher teacher = new Teacher();
Thread first = new SynchronizedThread("first", teacher);
Thread second = new AnotherSynchronizedThread("second", teacher);
first.start();
second.start();
}
static class SynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public SynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
teacher.say(name);
}
}
static class AnotherSynchronizedThread extends Thread {
private String name;
private Teacher teacher;
public AnotherSynchronizedThread (String name, Teacher teacher) {
this.name = name;
this.teacher = teacher;
}
@Override
public void run () {
Teacher.hello(name);
}
}
static class Teacher {
public void say(String name) {
synchronized(lock) {
System.out.println("
我正在教
" + name);
SleepUtil.sleep(3000);
System.out.println(name + "
睡眠三秒
");
}
}
public static void hello(String name) {
synchronized(lock) {
System.out.println("
我会说
hello");
System.out.println("hello " + name);
}
}
}
static class Test {
}
}
执行结果：
我正在教
first
first
睡眠三秒
我会说
hello
hello second
这种写法等效于类加同步，或者实例加同步，不过同步的对象变为了自己定义的另外一个对象。
synchronized
同步：
同步实例对象时，只对使用这个对象锁的方法有影响；
同步类时，只对使用这个类锁的方法有影响；

更多技术资讯可关注:itheimaGZ获取


avatar
文章
阅读
粉丝