Java-JUC(十一):线程8锁

题目:

判断以下8种情况,输出的内容

题目一:一个Number实例对象number,两个非静态同步方法getOne,getTwo,两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                number.getTwo();
            }
        }).start();
    }
}

class Number{
    public synchronized void getOne(){
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

one
two

题目二:一个Number实例对象number,两个非静态同步方法getOne,getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                number.getTwo();
            }
        }).start();
    }
}

class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

one
two

题目三:一个Number实例对象number,两个非静态同步方法getOne,getTwo,给getOne添加Thread.sleep(3000),新增普通方法getThree方法,三个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.getTwo,一个线程调用number.getThree),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                number.getTwo();
            }
        }).start();
        
        new Thread(new Runnable() {
            public void run() {
                number.getThree();
            }
        }).start();
    }
}

class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
    public void getThree(){
        System.out.println("three");
    }
}

输出结果:

three
one
two

题目四:两个Number实例对象number,number2,两个非静态同步方法getOne,getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number2.getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        final Number number2=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                // number.getTwo();
                 number2.getTwo();
            }
        }).start();
    }
}

class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

two
one

题目五:一个Number实例对象number,一个静态同步方法getOne,一个非静态同步方法getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                 number.getTwo();
            }
        }).start();
    }
}

class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

two
one

题目六:一个Number实例对象number,两个静态同步方法getOne,getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        //final Number number2=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                number.getTwo();
                // number2.getTwo();
            }
        }).start();
    }
}

class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public static synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

one
two

题目七:两个Number实例对象number,number2,一个静态同步方法getOne,一个非静态同步方法getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.2getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        final Number number2=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
//                number.getTwo();
                number2.getTwo();
            }
        }).start();
    }
}

class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

two
one

题目八:两个Number实例对象number,number2,两个静态同步方法getOne,getTwo,给getOne添加Thread.sleep(3000),两个线程打印输出(一个线程调用number.getOne,另外一个线程调用number.2getTwo),判断输出

package com.dx.juc.test;

public class Thread8Monitor {
    public static void main(String[] args) {
        final Number number=new Number();
        final Number number2=new Number();
        
        new Thread(new Runnable() {
            public void run() {
                number.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
//                number.getTwo();
                number2.getTwo();
            }
        }).start();
    }
}

class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    
    public static synchronized void getTwo(){
        System.out.println("two");
    }
}

输出结果:

one
two

总结:

1)静态方法锁是锁的Number.class(类的字节码,也是Class的实例);一个类中不管有多少个静态方法,不管访问它们的是多少个线程,这些线程都是公用同一个锁。

2)非静态方法锁是锁的this,也就是当前实例对象。this就是指当前类的实例对象,同一个实例对象通用一个锁,不同实例对象使用不用锁。

 

    原文作者:cctext
    原文地址: https://www.cnblogs.com/yy3b2007com/p/8981369.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞