如何判断锁的是谁? 永远知道是什么锁,
线程8锁:就是关于锁的8个问题
问题1:
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//8 锁--1
//资源类
Phone phone = new Phone();
new Thread(()->{ phone.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 先信息, 后打电话 因为资源类中的二个方法 都是 synchronized 修饰的, 他锁的是方法的调用者,由于调用者都是phone, 同一个调用者,所以谁先拿到锁,谁先执行
}
}
//资源类
class Phone{
//发短信
public synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public synchronized void call(){
System.out.println("打电话");
}
}
问题2: 资源类中的 call()方法是普通方法, sendMes()是synchronized修饰的, 此时打印结果是什么? 谁先执行?, 答案是: 打电话, 发信息
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//8 锁--1
//资源类
Phone phone = new Phone();
new Thread(()->{ phone.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 打电话 发信息 因为资源类sendMes()是 synchronized修饰,锁对象是调用者, call()是普通方法, 线程调用互不影响,
}
}
//资源类
class Phone{
//发短信
public synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public void call(){
System.out.println("打电话");
}
}
问题3: 资源类中的二个方法都是 synchronized修饰的, 此时有二个调用者,谁先执行? 结果为什么?
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//8 锁--1
//资源类
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{ phone1.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 打电话 发短信 因为资源类中的二个方法 都是 synchronized 修饰的, 他锁的是方法的调用者,由于调用者是二个, 二把锁, 互不干扰 ,
}
}
//资源类
class Phone{
//发短信
public synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public synchronized void call(){
System.out.println("打电话");
}
}
问题4: 资源类中的二个方法都是 static synchronized修饰的, 此时同一个调用者, 结果先打印谁?
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//8 锁--1
//资源类
Phone phone = new Phone();
new Thread(()->{ phone.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 发短信 打电话 因为资源类中的二个方法 都是 synchronized static 修饰的静态同步类,是在类加载的时候就有了锁,锁的是同一个class,所以这个锁,谁先拿到,谁先执行
}
}
//资源类
class Phone{
//发短信
public static synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public static synchronized void call(){
System.out.println("打电话");
}
}
问题5: 资源类中的二个方法都是 static synchronized修饰的, 此时二个调用者, 结果先打印谁?
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//8 锁--1
//资源类
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{ phone1.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 发短信 打电话 因为资源类中的二个方法 都是 synchronized static 修饰的静态同步方法,是在类加载的时候就有了锁,锁对象是class, 此时不管多少个调用者,所以这个锁,谁先拿到,谁先执行
}
}
//资源类
class Phone{
//发短信
public static synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public static synchronized void call(){
System.out.println("打电话");
}
}
问题6:资源类的方法,一个是 static synchronized 修饰的静态同步方法, 一个是synchronized 修饰, 同一个调用者, 此时谁先打印??
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//资源类
Phone phone = new Phone();
new Thread(()->{ phone.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 打电话 发短信 ,因为资源类中sednMes()是静态同步方法,锁的是class对象, call()方法是普通同步方法,锁的是调用者,相当于二把锁,互不干扰,sendMes,睡的时间长,所以后打印
}
}
//资源类
class Phone{
//发短信
public static synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public synchronized void call(){
System.out.println("打电话");
}
}
问题7 资源类的方法,一个是 static synchronized 修饰的静态同步方法, 一个是synchronized 修饰, 有二个调用者, 此时谁先打印??
public class LockDemo01 {
public static void main(String[] args) throws InterruptedException {
//资源类
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{ phone1.sendMes();},"A").start();
//这里睡1 秒, 保证线程B 能抢到执行权
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
//问: 此时是先打印: 发信息? 还是打电话,
//答: 打电话 发短信 ,因为资源类中sednMes()是静态同步方法,锁的是class对象, call()方法是普通同步方法,锁的是调用者,相当于二把锁,互不干扰,sendMes,睡的时间长,所以后打印
}
}
//资源类
class Phone{
//发短信
public static synchronized void sendMes(){
//这里睡4秒
try {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短消息");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//打电话
public synchronized void call(){
System.out.println("打电话");
}
}