2021-09-23 线程编程作业*2

选择题：

1.下列关于多线程中锁机制正确的是（ BC ）。
 A.关键字synchronized只能用于方法声明上。//方法，代码块
 B.成员方法使用synchronized，那么当前方法的锁对象为当前方法所属的对象 //成员方法成了线程锁的部分，锁住的是this
 C.静态方法使用synchronized，那么当前方法的锁对象为当前方法所属对象//静态方法成了同步块，是类对象，当前方法所属对象this就是类对象
 D.为了尽量避免多线程带来的安全问题，尽可能的扩大synchronized修饰的代码范围。//倒也不必

2.下列选项中关于synchronized的使用正确的是：（ C ）。
 A.private synchronized Object o; //不能修饰成员属性
 B.void go() {
synchronized() { /* code here */ }
} //修饰方法不用加对象
 C.public synchronized void go() { /* code here */ }
 D.private synchronized(this) void go() { /* code here */ } //修饰方法不用加对象

3.哪个关键字可以对对象加锁？( B  )
  A.transient     B.synchronized     C.serialize     D.static

4.下列代码说法正确的是：（ AB ）。
 public class DaemonThread extends Thread{
    public DaemonThread(String name){
       super(name);
    }
    public void run() {
       while (true) {
      System.out.println("Daemon thread running...");
     }
  }
   public static void main(String[] args) {
       DaemonThread dt = new DaemonThread("dtThread");
       dt.setDaemon(true);
       dt.start();
     } }
 A.名为dtThread的线程为守护线程 
 B.运行上述代码，main 线程一退出，则虚拟机退出
 C.运行上述代码，程序会一直跑下去，因为main线程结束了，但dt线程是一个无限循环，还没有结束，虚拟机不能退出
 D.main线程是守护线程

编程题：

1. 采用匿名内部类的方式创建2个线程，一个线程为计时线程，每隔2s输出当前时间的毫秒表示，
另一个线程为前台线程，任务是线程开始，休眠10秒结束，当前台线程结束，计时线程也随之结束。请完成以上案例。

Thread t1 = new Thread(){
            @Override
            //计时线程，不确定循环次数，用死循环。
            public void run() {
                while (true){
                    try {
                        System.out.println("现在时间是："+System.currentTimeMillis()+"ms");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        //前台线程，休眠10秒后结束，直接睡着就完事
        Thread t2 = new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //t2是前台线程，结束时t1也要结束，所以t1应该设施为守护线程
        t1.setDaemon(true);
        t1.start();
        t2.start();

2. 创建2个线程对象表示2个人，二人都要完成在客厅看电视5s，然后去卫生间5s的任务，已知二人同时开始执行任务。 要求：2个人可以同时在客厅看电视，但是上厕所不能同时上，只能排队上

线程锁：定义两个方法，

第一个：看电视5s是共同的，俩线程可以一起走，是普通方法。

第二个：上厕所是排队的，是线程锁修饰的方法，把上厕所锁住就行：

//封装一个类，里面是俩方法：
class Action{
    public void watchTV(){
        try {
            System.out.println("我在看电视啦~");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized  void gotoWC(){
        try {
            System.out.println("我在上厕所啦~");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//main调用：
        Action a = new Action();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                a.watchTV();
                a.gotoWC();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                a.watchTV();
                a.gotoWC();
            }
        };
        t1.start();
        t2.start();

同步块：

定义一个方法，顺序执行：看电视，5s，上厕所，5s

看电视是大家一起看，俩线程公用，上厕所是排队的，把这块代码锁上就行，用同步块

//封方法：
class Action{
    public void action(){
        try {
            System.out.println("我在看电视啦~");
            Thread.sleep(5000);
            synchronized (this) {
                System.out.println("我在上厕所啦~");
                Thread.sleep(5000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//main调用：
        Action a = new Action();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                a.action();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                a.action();
            }
        };
        t1.start();
        t2.start();