多线程 - 练习题（一）

第一章节

线程的定义

一条在程序代码中独立执行的路径

 给出runnable的定义

一段封装在对象中的代码序列，它的类实现了runnable接口

thread类和runnable接口完成了什么

类thread提供了一个底层操作系统线程架构的统一。runnable接口为关联thread对象的线程提供执行代码。

创建一个runnable对象的两种方式

创建一个实现了runnable的匿名类；使用lambda表达式；

关联一个runnable到thread对象的两种方式

把一个runnable传递到thread类的接受runnable参数的构造函数；继承thread类重写run（）

thread的五种状态

状态的5个标识：线程名字，线程存活的标识，线程的执行状态，线程的优先级，线程是否为守护线程；

确定线程的死活？

isalive（）方法

thread.state枚举的所有的常量

new：线程还没有开始执行

runable：该线程正在jvm中执行

blocked：线程被阻塞，正在等待一个监听锁

waitting：无限制地等待另一个线程执行特定的操作

terminated：线程已经退出

 获取当前线程执行状态

getState（）

让一条线程等待另一个线程直到死亡的thread的方法

void join（）

package thread;

public class t20190904 {

  public static void main(String[] args) throws InterruptedException {

    Thread t = new Thread(() -> {
      boolean flage = true;
      while (flage){
        System.out.println("hello");
        try {
          Thread.sleep(100);
         
        } catch (InterruptedException e) {
          System.out.println("interrupted");
          flage  = false;
          e.printStackTrace();
        }
      }
    });
    t.start();

    Thread.sleep(2000);
    t.interrupt();
  }
}

这是我写的，答案用的是while（true） 和break

 第二章

线程相关的三个问题

竞态条件；数据竞争；缓存变量

给出同步的定义

同步指的是jvm的特性，它用于保证两条及两条以上的线程不会同时在一个临界区执行

同步的两种属性

互斥；可见

同步是如何实现出来的

同步是机遇监听器出来的，它是控制对临界区访问的并发构架，必须不可分割的执行。每个java对象都关联

着一个监听器，线程可以通过上锁或解锁的方式获取或者释放监听器上的锁。

 三种活跃性挑战

死锁，活锁，饿死

如何区分volatile和synchronized关键字

volatile只处理了可见性，而synchronized处理的可见性和互斥性

第三章

支持条件的api

wait（），notify

判断：wait（）可以被中断

对的

判断：Object的wait（）方法并不会释放锁

错的。和Thread的sleep相反。

 

提示：

 

package thread;


public class t20190910 {

  private static volatile int i = 0;

  static  Object object = new Object();

  public static void main(String[] args) {


    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getId()+"等待中。。。。");
        synchronized (object){


          i++;
          try {
            //sleep 不会释放锁
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }

          try {
            while (i < 3){
              //wait()方法会释放锁
              object.wait();
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          }

        }


        System.out.println(Thread.currentThread().getId()+"线程终止 ");
      }
    };


    Thread t1 = new Thread(runnable);
    Thread t2 = new Thread(runnable);
    Thread t3 = new Thread(runnable);

    t1.start();
    t2.start();
    t3.start();

    Runnable r = new Runnable() {
      @Override
      public void run() {
        while(i<3){
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        synchronized (object){
          object.notifyAll();
        }
      }
    };

    Thread tt = new Thread(r);
    tt.start();
  }
}

解释说明下：

synchronized (object) 很有意思，如果你注释掉第一个，程序跑2秒多，因为你3个线程同时跑。不注释是6秒多，你的线程是顺序执行。

如果你注释第二个报错，属于非法获得监听。