java锁方法和锁代码块_java的同步方法和同步代码块，对象锁，类锁区别

/**

* @author admin

* @date 2018/1/12 9:48

* 做用在同一个实例对象上讨论

* synchronized同步方法的测试

* 两个线程，一个线程调用synchronized修饰方法，另外一个线程能够调用非synchronized修饰的方法，互不影响

*/

public class SynchronizedTest {

public synchronized void methodA() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodA-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void methodB() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodB-" + i );

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

SynchronizedTest test = new SynchronizedTest();

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

test.methodA();

}

});

thread1.start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

test.methodB();

}

});

thread2.start();

}

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodB-2

methodA-2

methodA-3

methodB-3

methodA-4

methodB-4

/**

* @author admin

* @date 2018/1/12 10:16

* 做用在同一个实例对象上讨论

* Sychronized代码块的测试

* 两个线程，一个线程执行synchronized代码块，另外一个线程执行非synchronized代码块

*/

public class SychronizedTest2 {

public void methodA() {

synchronized (this) {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodA-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public void methodB() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodB-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

SychronizedTest2 test2 = new SychronizedTest2();

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

test2.methodA();

}

});

thread1.start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

test2.methodB();

}

});

thread2.start();

}

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodA-2

methodB-2

methodB-3

methodA-3

methodA-4

methodB-4

/**

* @author admin

* @date 2018/1/12 10:33

* 做用在同一个实例对象上讨论

* Synchronized同步方法和同步代码块

* 一、synchronized和synchronized(this)两者没区别，都做用在this对象锁上面，因此会同步

* 二、synchronized(obj)，这个是做用在obj对象锁上面，和this对象锁不一样，因此不会同步

*/

public class SynchronizedTest3 {

public synchronized void methodA() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodA-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void methodB() {

synchronized (this) {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodB-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public void methodC() {

Object obj = new Object();

synchronized (obj) {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodC-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

SynchronizedTest3 test3 = new SynchronizedTest3();

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

test3.methodA();

}

});

thread1.start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

test3.methodB();

}

});

thread2.start();

Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

test3.methodC();

}

});

thread3.start();

}

}

运行结果：

methodA-0

methodC-0

methodA-1

methodC-1

methodA-2

methodC-2

methodA-3

methodC-3

methodA-4

methodC-4

methodB-0

methodB-1

methodB-2

methodB-3

methodB-4

/**

* @author admin

* @date 2018/1/12 10:48

* 做用在同一个类上讨论，每个类只有一个类锁

* synchronized类锁

* static synchronized 和 synchronized(SynchronizedTest4.class),都是做用在同一个类锁上，因此会同步

*/

public class SynchronizedTest4 {

public synchronized static void methodA() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodA-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void methodB() {

synchronized (SynchronizedTest4.class) {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodB-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

SynchronizedTest4 test4 = new SynchronizedTest4();

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

test4.methodA();

}

});

thread1.start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

test4.methodB();

}

});

thread2.start();

}

}

运行结果：

methodA-0

methodA-1

methodA-2

methodA-3

methodA-4

methodB-0

methodB-1

methodB-2

methodB-3

methodB-4

/**

* @author admin

* @date 2018/1/12 11:03

* synchronized的对象锁和static synchronized的类锁，是两个不一样的锁，因此不会同步

* 两个线程，一个调用对象锁，一个调用类锁

*/

public class SynchronizedTest5 {

public synchronized void methodA() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodA-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public synchronized static void methodB() {

try {

for (int i = 0; i < 5; i++) {

System.out.println("methodB-" + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

SynchronizedTest5 test5 = new SynchronizedTest5();

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

test5.methodA();

}

});

thread1.start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

test5.methodB();

}

});

thread2.start();

}

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodB-2

methodA-2

methodB-3

methodA-3

methodB-4

methodA-4