Java面试知识点（二）——Java基础之多线程_java面试知识点大纲process-CSDN博客

本文链接：https://blog.csdn.net/qq_43988365/article/details/106665099

1.程序

完成特定任务，使用某种语言编写的一组指令的集合（一段静态的代码）

2.进程（Process）

一次程序的执行过程，正在运行的一个程序（有它自身产生存在消亡的过程）
进程作为资源的分配单位，系统在运行时会分配不同的内存区域

3.线程（Thread）

进程可以进一步细化成为线程（一个程序内部的一条执行路径）

若一个进程在同一时间并行多个线程，那么就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC）
一个进程中的多个线程共享一个方法区和堆，使得线程间的通信更加简便、高效
多个线程操作共享的系统资源会发生安全隐患

一个Java应用程序至少有三个线程

主线程
垃圾回收线程
异常处理线程

4.并行与并发

并行： 多个CPU执行多个任务
并发： 一个CPU（采用时间片）同时执行多个任务

5.使用多线程的优点

1.提高应用程序的相应，对图形界面更有意义
2.提高CPU利用率
3.改善程序结构，将即长又复杂的进程分为多个线程独立运行

6.什么时候需要多线程？

1.程序需要用时运行多个任务
2.程序需要实现一些需要等待的任务
3.需要一些后台运行的程序时

7.线程的生命周期

新建： 当Thread类或其子类的对象被声明并创建时
就绪： start（）后，具备运行的条件，只是没分配到资源
运行： 就绪的线程被调度，获取CPU资源，进入运行状态
阻塞： 被人为挂起或执行输入输出时
死亡： 完成工作

8.线程中的常用方法

Thread类
1.start();启动当前线程、调用当前线程的run()方法
2.run()：通常需要重写Thread类中的此方法，将线程的要执行的操作声明在此方法中
3.currentThread();静态方法：返回执行当前代码的线程
4.getName()：获取当前线程的名字
5.setName()：设置当前线程的名字
6.yield()：释放当前CPU的执行权
7.join():在线程A中调用线程B的join方法，此时线程A进入阻塞状态，直到线程B执行完以后才结束阻塞状态
8. sleep(Long millis):让当前线程睡眠，指定的millitime毫秒时间内，当前线程是阻塞状态
9.isAlive():判断线程是否存活
线程的优先级 优先级比较高的线程要抢占低优先级cpu执行权，只是概率较高，不一定只有当高优先级的线程执行完以后低优先级的才会执行
10.getPriority()获取线程优先级。优先级范围值为 1-10 (默认值为 5)，相邻值之间的差距对 cpu 调度的影响很小。一般使用 3 个字段 MIN_PRIORITY、NORM_PRIORITY、MAX_PRIORITY 分别表示 1、5、10 三个优先级，这三个优先级可较大地区分 cpu 的调度。
11. setPriority(int newPriority)设置线程优先级。
Object类
1.wait(): 线程进入某个线程池中并进入睡眠态。等待 notify () 或 notifyAll () 的唤醒。
2.notify(): 从某个线程池中随机唤醒一个睡眠态的线程。
3.notifyAll(): 唤醒某个线程池中所有的睡眠态线程。

9.多线程的启动方式

①继承Thread类
（1）定义Thread类的子类，并重写其run()方法，run()方法的方法体中声明线程需要完成的任务（线程执行体）
（2）创建Thread子类的实例
（3）调用线程对象的start()方法启动线程

class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread() + "：" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();

        m1.start();//1.启动当前线程
        //2.使用当前线程的run（）

        //问题一：我们不能通过直接调用run（）的方式启动线程
        // m1.run();

        //问题二：再启动一个线程，遍历100以内的偶数
        //m1.start(); 不可以让已经start（）的线程去执行

        //我们需要重新创建一个新的线程对象
        MyThread m2 = new MyThread();

        m2.start();

        //如下操作仍然是在main线程中执行
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread() + "：" + i + "***************");
            }
        }
    }
}

②实现Runnable接口
（1）定义Runnable接口的实现类，重写run()方法
（2）创建实现类的实例对象，
（3）创建Thread类的对象，将实现类对象以参数的形式传入
（4）调用Thread类对象的start()方法

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        MThread m1 = new MThread();

        Thread tt = new Thread(m1);

        tt.start();
    }
}

③实现Callable接口
如果要进行多线程就需要实现Runnable接口，缺点：当线程执行完毕后，无法获取一个返回值，在JDK1.5之后提出了一个新的线程实现接口：java.util.concurrent.Callable

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

在可以设置一个泛型，此泛型的类型就是返回数据的类型，可以避免向下转型带来的安全隐患

10.解释Runnable与Callable的区别

Runnable接口是在JDK1.0时提出的多线程的实现接口
Callable接口是在JDK1.5之后提出的
Runnable接口之中只提供了run()方法，并且没有返回值
Callable接口提供call()方法，可以有返回值

④使用线程池

11.多线程sleep()和wait()

sleep()是Thread类的静态方法，wait()是Object类的成员方法
sleep () 方法导致了程序暂停执行指定的时间，让出 cpu 给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。在调用 sleep () 方法的过程中，线程不会释放对象锁。
wait() 是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了 notify 方法（notify 并不释放锁，只是告诉调用过 wait 方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放），调用 wait 方法的一个或多个线程就会解除 wait 状态，重新参与竞争对象锁，程序如果可以再次得到锁，就可以继续向下运行。
sleep 方法需要抛异常，wait 方法不需要
Thread类中sleep方法就已经进行了抛异常处理
sleep 方法可以在任何地方使用，
wait 方法只能在同步方法和同步代码块中使用

12.线程的同步

当我们使用多个线程访问同一资源时（多个线程对资源有写操作），就很容易出现线程安全问题，Java中提供了同步机制（synchronized）来解决，在某个线程修改共享资源时，其他线程不能修改资源，等待修改完毕同步以后，才能去抢夺CPU资源，保证了数据的同步性，解决了安全问题。
三种方式完成同步操作

同步代码块
同步方法
锁机制

同步代码块
synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

synchronized(同步锁){
	需要同步的代码
}

同步锁
对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁

public class Ticket implements Runnable{
	private int ticket = 100;

	Object lock = new Object();
	
	@override
	public void run(){
		while(true){
			synchronized(lock){
				if(ticket > 0){
					try{
						Thread.sleep(50);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread.getName()+"正在卖"+ticket--);
				}
			}
		}
	}
}

使用同步代码块解决线程的安全问题

同步方法
使用synchronized修饰的方法叫同步方法，保证A线程执行该方法时，其他线程只能在方法外等候。

public synchronized void method(){
	可能会产生线程安全问题的代码
}

这时的同步锁是谁？
对于非static方法，同步锁就是this，谁调用这个方法，锁就是谁
对于static方法，锁就是当前方法所在类的字节码对象（类.class）

public class Ticket implements Runnable{
	private int ticket = 100;
	
	@override
	public void run(){
		while(true){
			sell();
		}	
	}
	public synchronized void sell(){
				
				if(ticket > 0){
					try{
						Thread.sleep(50);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread.getName()+"正在卖"+ticket--);
		}
	}
}

synchronized的缺点
1.当一个代码被synchronized修饰的时候，代表一个线程获取了锁，执行代码块，其他线程就需要等待这个线程释放锁（代码执行完毕自动释放/发生异常JVM让线程释放），那么如果这个线程调用sleep()方法等等被阻塞，无法释放锁，这个时候其他线程就一直等待，影响了效率
2.当文件被多个线程同时操作时，读与写发生了冲突，写操作与写操作发生冲突，读操作不会与读操作发生冲突，使用synchronized就会导致在一个线程读操作时其他线程想读就需要等待
3.在使用synchronized时，无法得知线程是否成功获取到了锁

Lock锁
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和方法更加广泛的锁定操作，它有的Lock都有，更加的强大。

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

Lock锁也称为同步锁，加锁与释放锁都方法化了。
ReentrantLock 是 Lock 的一个实现类（另外两个实现类是 ReentrantReadWriteLock 类下的两个静态内部类：WriteLock 和 ReadLock），它的意思是可重入锁，ReentrantLock 中提供了更多的一些方法。不过常用的就是 Lock 中的这些。

public void lock();//加锁
public void unlock();//释放锁

tryLock () 是一个 boolean 类型的方法，当调用这个方法的时候，线程会去尝试获取锁，如果获取到的话会返回 true，如果获取不到返回 false，也就是说这个方法会立马返回一个结果，线程不会等待。

tryLock (long time, TimeUnit unit) 是上面 tryLock () 方法的一个重载方法，加了两个参数，给定了等待的时间，如果在规定时间拿到锁返回 true，如果拿不到返回 false。这两个方法的一般用法和 Lock 类似。

使用如下：

public class Ticket implements Runnable{
	private int ticket = 100;
	ReentrantLock rl = new ReentrantLock();	
	@override
	public void run(){
		while(true){
			rl.lock();
				if(ticket > 0){
					try{
						Thread.sleep(50);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread.getName()+"正在卖"+ticket--);
			}
			rl.unlock();
		}
	}
}

13.synchronized和Lock的区别

1.实现层面：synchronized（JVM层面）、Lock（JDK层面）
2.响应中断：Lock可以让等待锁的线程响应中断，而使用synchronized时，线程会一直等待下去，不能够响应中断
3.立即返回：Lock可以让线程尝试获取锁，无法获取锁时立即返回或等待一段时间，synchronized无法做到
4.读写锁：Lock可以提高多个线程进行读操作的效率
5.可实现公平锁：Lock可以实现公平锁，synchronized天生就是非公平锁
6.synchronized在发生异常时，自动释放锁，不会死锁。Lock需要在finally块中释放锁。

14.synchronized和ReentrantLock有什么区别

synchronized 是 Java 内建的同步机制，所以也有人称其为 Intrinsic Locking，它提供了互斥的语义和可见性，当一个线程已经获取当前锁时，其他试图获取的线程只能等待或者阻塞在那里。
ReentrantLock，通常翻译为可重入锁，是 Java 5 提供的锁实现，它的语义和 synchronized 基本相同。与此同时，ReentrantLock 提供了很多实用的方法，能够实现很多 synchronized 无法做到的细节控制。编码中也需要注意，必须要明确调用 unlock() 方法释放，不然就会一直持有该锁。

1）ReentrantLock 使用起来比较灵活，可以对获取锁的等待时间进行设置，可以获取各种锁的信息，但是必须有释放锁的配合动作；
2）ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
3）ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。
4）synchronized是关键字，ReentrantLock是类
5）Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的
6）ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。
7）ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
8）ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

场景：
在确实需要一些 synchronized 所没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票。 ReentrantLock 还具有可伸缩性的好处，应当在高度争用的情况下使用它，但是请记住，大多数 synchronized 块几乎从来没有出现过争用，所以可以把高度争用放在一边。我建议用 synchronized 开发