诺瓦科技面试总结
一. 进程间的通信
进程间的通信（IPC）是指在不同进程之间传播或交换信息。
IPC的方式通常有管道、消息队列、信号量、共享存储、Socket和Streams等。其中Socket和Stream支持不同主机上的两个进程IPC。
- 管道：
匿名管道概念：在内核中申请一块固定大小的缓冲区，程序拥有写入和读取的权利，一般使用fork函数实现父子进程的通信。（它可以看成一个特殊的文件。对于它的读写也可以使用普通的read，write等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存之中。）
当一个管道建立时，它会创建两个文件描述，fd[0]为读打开，fd[1]为写打开。
单个进程的管道几乎没有任何用处。所以，通常调用pipe的进程接着调用fork，这样就创建了父进程与子进程之间的IPC通道。
命名管道（FIFO）概念：在内核中申请一块固定大小的缓冲区，程序拥有写入和读取的权利，没有血缘关系的进程也可以进程间通信。（有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中）
FIFO的通信方式类似于进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道同时清除数据，并且“先进先出”。
特点：
- 面向字节流
- 生命周期随内核
- 自带同步互斥机制
- 半双工（即数据只能在一个方向上流动），具有固定的读端和写端。单向通信，两个管道实现双向通信。
2. 消息队列：
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
特点： - 消息队列是面向记录的，其中消息具有特定的格式以及特定的优先级。
- 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
- 消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。
3. 信号量：
信号量是一个计数器，信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。最简单的信号量只能取0和1变量，这也是信号量最常见的一种形式，叫做二值信号量。而可以取正整数的信号量被称为通用信号量。
特点：
- 信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
- 信号量基于操作系统的PV操作（P操作意味着进程请求一个资源，V操作意味着进程释放一个资源），程序对信号量的操作都是原子操作。
- 每次对信号量的PV操作不仅限于对信号量加1或减1，而且可以加减任意正整数。 支持信号量组。
4. 共享内存：
共享内存，指两个或多个进程共享一个给定的存储区。
特点：
- 共享内存是最快的一种IPC，因为进程是直接对内存进行存取。 因为多个进程可以同时操作，所以需要进行同步。
- 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
五种通信方式总结：
1.管道：速度慢，容量有限，只有父子进程能通讯
2.FIFO：任何进程间都能通讯，但速度慢
3.消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题
4.信号量：不能传递复杂消息，只能用来同步
5.共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存
二.线程如何同步？
Java允许多线程并发控制，当多个线程同时操作一个可共享资源变量时，将会导致数据不准确，相互之间产生冲突。因此加入同步锁以避免在该线程没有完成操作之前，被其他线程调用。从而保证了该变量的唯一性和准确性。
1.同步方法
即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
【代码示例】
//同步方法
package Thread;
public class TicketRunnableImpl implements Runnable{
private int ticketNum=1000;
@Override
public void run() {
while(ticketNum>0){
sellTickets();
}
}
public synchronized void sellTickets() {
//判断
if(ticketNum>0){
ticketNum--;
System.out.println(Thread.currentThread().getName()+"售出一张票，剩余："
+ticketNum);
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public static void main(String[] args){
TicketRunnableImpl t=new TicketRunnableImpl();
t.run();
}
}
2.同步代码块
即有synchronized关键字修饰的语句块
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。
【代码示例】
//同步代码块
package Thread;
public class TicketRunnableImpl2 implements Runnable{
private int ticketNum=1000;
@Override
public void run() {
while(ticketNum>0){
//同步代码块
synchronized (this) {
if(ticketNum>0){
ticketNum--;
System.out.println(Thread.currentThread().getName()+"售出一张票，剩余："
+ticketNum);
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args){
TicketRunnableImpl2 t=new TicketRunnableImpl2();
t.run();
}
}
3.使用重用锁（对象锁）实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力
ReenreantLock类的常用方法有：
- ReentrantLock() : 创建一个ReentrantLock实例
- lock() : 获得锁
- unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 ，使用该类注意及时释放锁。
【代码示例】
//重用锁
package Thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TicketRunnableImpl3 implements Runnable{
private int ticketNum=1000;
//创建锁对象
Lock lock=new ReentrantLock();
@Override
public void run() {
while(ticketNum>0){
//上锁
lock.lock();
//判断
if(ticketNum>0){
ticketNum--;
System.out.println(Thread.currentThread().getName()+"售出一张票，剩余："
+ticketNum);
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
}
//解锁
lock.unlock();
}
}
public static void main(String[] args){
//创建接口实现类实例化对象
Runnable t=new TicketRunnableImpl3();
//创建线程
Thread t1=new Thread(t,"窗口一");
Thread t2=new Thread(t,"窗口二");
Thread t3=new Thread(t,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
4.使用局部变量实现线程同步
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
- ThreadLocal() : 创建一个线程本地变量
- get() : 返回此线程局部变量的当前线程副本中的值
- initialValue() : 返回此线程局部变量的当前线程的"初始值"
- set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
【代码示例】
//局部变量
package Thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TicketRunnableImpl4 implements Runnable{
private volatile int ticketNum=1000;
@Override
public void run() {
while(ticketNum>0){
//判断
if(ticketNum>0){
ticketNum--;
System.out.println(Thread.currentThread().getName()+"售出一张票，剩余："
+ticketNum);
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public static void main(String[] args){
//创建接口实现类实例化对象
Runnable t=new TicketRunnableImpl4();
//创建线程
Thread t1=new Thread(t,"窗口一");
Thread t2=new Thread(t,"窗口二");
Thread t3=new Thread(t,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
5.使用特殊域变量（volatile）实现线程同步
- a.volatile关键字为域变量的访问提供了一种免锁机制。
- b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新。因此每次使用该域就要重新计算，而不是使用寄存器中的值
- c.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
【代码示例】
package Thread;
public class TicketRunnableImpl5 implements Runnable{
private static ThreadLocal<Integer> ticketNum=new ThreadLocal<Integer>(){
@Override
protected Integer initialValue(){
return 1000;
}
};
@Override
public void run() {
while(ticketNum.get()>0){
//判断
if(ticketNum.get()>0){
ticketNum.set(ticketNum.get()-1);
System.out.println(Thread.currentThread().getName()+"售出一张票，剩余："
+ticketNum.get());
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public static void main(String[] args){
//创建接口实现类实例化对象
Runnable t=new TicketRunnableImpl5();
//创建线程
Thread t1=new Thread(t,"窗口一");
Thread t2=new Thread(t,"窗口二");
Thread t3=new Thread(t,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
三、线程如何终止？
终止一个线程通常意味着在线程处理任务完成之前停掉正在做的操作，也就是放弃当前操作。
在Java中有以下三种方法可以终止正在运行的线程：
1.使用退出标志，使线程正常退出，也就是当run()方法完成后线程终止。
2.使用stop()方法强行终止线程，但是不推荐该方法，该方法已经被弃用。
3.使用interrupt方法终止线程。
1.使用标志位终止线程
在 run() 方法执行完毕后，该线程就终止了。但是在某些特殊的情况下，run() 方法会被一直执行；比如在服务端程序中可能会使用 while(true) { … } 这样的循环结构来不断的接收来自客户端的请求。此时就可以用修改标志位的方式来结束 run() 方法。
【代码示例】
package Thread;
public class ThreadFlag extends Thread{
public volatile boolean exit=false;
@Override
public void run(){
while(!exit){
System.out.println("aaa");
}
}
public static void main(String[] args) throws Exception{
ThreadFlag thread =new ThreadFlag();
thread.start();
sleep(5000);
thread.exit=true;
//join()方法的作用是调用线程等待该线程完成后，才能继续向下运行
thread.join();
System.out.println("线程退出！");
}
}
2.使用stop方法强制终止线程（已弃用）
使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程：
thread.stop();
为什么弃用stop：
1.调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作，包括在 catch 或 finally 语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。
2.调用 stop() 方法会立即释放该线程所持有的所有的锁，导致数据得不到同步，出现数据不一致的问题。
3.使用Interrupt中断线程
使用interrupt方法来终端线程可分为两种情况：
（1）线程处于阻塞状态，如使用了sleep方法。
【代码示例】
package Thread;
public class ThreadInterrupt extends Thread{
@Override
public void run(){
try{
sleep(5000);
}
catch(InterruptedException e){
System.out.println(e.getMessage());
}
}
public static void main(String[] args) throws Exception{
Thread thread=new ThreadInterrupt();
thread.start();
System.out.println("在50秒内按任意键中断线程");
System.in.read();
thread.interrupt();
thread.join();
System.out.println("线程已退出");
}
}
（2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
【代码示例】
package Thread;
public class ThreadInterrupt2 extends Thread{
@Override
public void run(){
for(int i=0;i<100000;i++){
while(!isInterrupted()){
break;}
System.out.println("i="+i);
}
}
public static void main(String[] args) throws Exception{
Thread thread=new ThreadInterrupt2();
thread.start();
thread.sleep(5000);
thread.interrupt();
thread.join();
System.out.println("线程已退出");
}
}
在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。
注意：在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted()，一个是非静态的方法isInterrupted()，这两个方法的区别是interrupted用来判断当前线是否被中断，而isInterrupted可以用来判断其他线程是否被中断。因此，while (！isInterrupted())也可以换成while (！Thread.interrupted())。