java基础篇---线程问题

1：继承 Thread 类，为什么要继承 run 方法

答案： Thread 实现了 Runnable 接口，

而 run 方法是 Runnable 的方法，接口中的方法
默认 public abstract。如果继承 Thread 类，不重写 run 方法，不会报错，但是无法指
定线程运行的代码。

2：进程和线程的区别

答案：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。
线程是进程的一个实体，是 CPU 调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），一个线程可以创建和撤销另一个线程；
进程和线程的关系：
①一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
②资源分配给进程，同一进程的所有线程共享该进程的所有资源。
③线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
④处理机分给线程，即真正在处理机上运行的是线程。
⑤线程是指进程内的一个执行单元，也是进程内的可调度实体。
线程与进程的区别：
①调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
②并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
③拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
④系统开销：在创建或撤销进程的时候，由于系统都要为之分配和回收资源，导致系统的明显大于创建或撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式下不会对其他的进程产生影响，而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但是在进程切换时，耗费的资源较大，效率要差些。

线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大的提高了程序运行效率。线程在执行过程中，每个独立的线程有一个程序运行的入口，顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，有应用程序提供多个线程执行控制。

从逻辑角度看，多线程的意义子啊与一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

3：出现死锁的条件

出现死锁有 4 个必要条件： ①互斥：存在互斥使用的资源，也就是临界资源； ②占有等待：拥有资源的进程都在等待另外的资源； ③非剥夺：进行所占有的资源是不可剥夺使用的资源； ④循环等待：都在相互等待资源。

4：Synchronized 锁与 lock 锁有什么区别

① synchronized 锁只锁括号里面的代码内容，一个方法或者一个类等等。如果被锁的代码抛出异常会自动释放锁资源。

② lock 锁锁定 lock 和 unlock 之间的代码，被锁的代码抛出异常不会自动释放锁资源，需要 try catch 后在 finally 里面手动 unlock 释放锁资源。

5：多线程中同步与锁

Lock 替代了 synchronized；而 Condition 替代了 Object 中的监视器方法（ wait,notify,notifyall）使用， Condition 可以通过 Lock 锁获取，一个 Lock 可以对应多个 Condition。

class Resource{
private String name;
 private int count = 1;
 private boolean flag = false;//定义标志，用于进程间切换
 private Lock lock = new ReentrantLock();
 private Condition con = lock.newCondition();
//private Condition con_pro = lock.newCondition();
//private Condition con_con = lock.newCondition();
//此处抛了异常，在处理线程时一定要记得做异常处理
 public void set(String name)throws InterruptedException{
 lock.lock();//上锁， lock()与 unlock()其实就类似于 synchronized ，只是 lock
必须手动上锁和解锁
 try{
 while(flag)
 con.await();//线程等待，类似于 wait
//con_pro.await();
 this.name = name+"-->"+count++;
 System.out.println("生产者.."+this.name);
 flag = true;
 con.signalAll();//唤醒全部线程，类似于 notifyAll
//con_con.signal();
}
 finally{
 lock.unlock();//释放锁
 }
 }
//此处抛了异常，在处理线程时一定要记得做异常处理
 public void out()throws InterruptedException{
 lock.lock();//上锁
 try{
 while(!flag)
 con.await();//线程等待
//con_con.await();
 System.out.println("消费者.."+this.name);
 flag = false;
 con.signalAll();//唤醒线程
//con_pro.signal();
 }
 finally{
 lock.unlock();//释放锁
 }
 }
}
//以上注释的代码，实现了等待本方线程和只唤醒对方线程的功能。

6：多线程中 stop 为什么不合适

多线程之间一般是有联系的，若用 stop 停止了线程，容易强行打断线程之间的联系，容易产生错误。

7：同步代码块和同步方法的区别

同步方法持有的锁匙是 this，即本类对象。而同步代码块可以自定义一把锁，语法为：synchronized(对象){同步内容}，当然这个对象也可以是 this。同步代码块的作用域小于同步函数,而同步函数的作用域大于同步代码块，同步代码块效率相对更高。

8：Sleep 和 wait 的区别

①sleep 是 Thread 类中的， wait 是 Object 中的； ②sleep 会在指定时间之后自动唤醒， wait 需要其他线程调用 notify 或者 notifyAll 唤醒； ③sleep 还有个最大的特点就是谁调用，谁睡觉，即使在 a 类中调用 b 的 sleep 方法，实际上还是 a 去睡觉。 ④wait 只能使用在同步控制方法或者同步控制块中使用， sleep 在任何地方都能被使用； ⑤持有锁的线程执行 sleep，不释放锁，持有锁的线程执行到 wait（）时锁释放。

9：线程的五个状态和特点

①新建状态(New)：新创建了一个线程对象。
②就绪状态(Runnable)：线程对象创建后,其他线程调用了该对象的 start()方法.该状态的线程位于可运行线程池中,变得可运行,等待获取 CPU 的使用权.
③运行状态(Running)：就绪状态的线程获取了 CPU,执行程序代码.
④阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃
CPU 使用权,暂时停止运行.直到线程进入就绪状态,才有机会转到运行状态.阻塞的情况分三种： A）等待阻塞：运行的线程执行 wait()方法,JVM 会把该线程放入等待池中。 B）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用,则 JVM 会把该线程放入锁池中。 C）其他阻塞：运行的线程执行 sleep()或 join()方法,或者发出了 I/O 请求时,JVM 会把该线程置为阻塞状态.当 sleep()状态超时
join()等待线程终止或者超时或者 I/O 处理完毕时,线程重新转入

10：同步函数锁问题

public class Demon {
//1.静态方法同步函数
 public static synchronized void method1(){}
//2.非静态方法同步
 public synchronized void method2(){}
//3.这个方法可以等价与静态方法同步函数，即静态方法同步函数省略了锁为 Demon.class
的静态代码块,因为静态方法是被类本身调用的，而每个类初始化的时候加载了 class 字节码，
所以锁是 Demon.class
 public void method3(){
 synchronized(Demon.class){}
 }
//4 这个方法可以等价为非静态方法同步函数，也就是非静态方法底层的实现原理
//注意这个时候，静态代码块的锁就是 this,因为函数需要被对象调用，那么函数都有一个
所属对象引用，所以用 this。
 public void method4(){
 synchronized(this){}
 }
//需要同步的一般是多线程的情况，并且涉及到操作共享数据。
}