package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 两个普通同步方法 发短信 打电话
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone=new Phone();
new Thread(phone::sendSms,"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(phone::call,"B线程").start();
}
}
class Phone{
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 两个同步方法,一个睡眠4秒 发短信 打电话
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone=new Phone();
new Thread(phone::sendSms,"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(phone::call,"B线程").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
从上面两个例子可以看出synchronized 锁住了这个对象的调用者,两个方法用的是同一个锁,谁先拿到谁执行!
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 一个同步方法,一个普通方法 hello 发短信
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone=new Phone();
new Thread(phone::sendSms,"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(phone::hello,"B线程").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
这里没有锁!不是同步方法,不受锁的影响
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 两个对象 两个调用者,两把锁! 打电话 发短信
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone1=new Phone();
Phone phone2=new Phone();
new Thread(phone1::sendSms,"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(phone2::call,"B线程").start();
}
}
class Phone{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 两个静态方法 synchronized锁的是class类模板 发短信 打电话
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone1=new Phone();
new Thread(()->{phone1.sendSms();},"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone1.call();},"B线程").start();
}
}
class Phone{
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
}
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 一个静态方法,一个对象 打电话 发短信
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone1=new Phone();
new Thread(()->{phone1.sendSms();},"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone1.call();},"B线程").start();
}
}
class Phone{
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.qcby.lock;
import java.util.concurrent.TimeUnit;
/**
* @author HuangHaiyang
* @date 2020/07/06
* @description: description
* @version: 1.0.0
*/
/**
* @Date: 2020/7/6
* 一个静态方法,两个对象 打电话 发短信
* @return:
*/
public class SyncTest {
public static void main(String[] args) {
Phone phone1=new Phone();
Phone phone2=new Phone();
new Thread(()->{phone1.sendSms();},"A线程").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone2.call();},"B线程").start();
}
}
class Phone{
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
判断出synchronized锁的是什么,就可以判断出顺序