复习进程与线程, 复习对比synchronize的和lock，华为2024深圳春招面试

• 线程是处理器调度和执行的最小单位, 是进程下的独立的一个执行载体

• 一个进程最少包括一个线程, 也就是进程中的任务是由线程去执行的

• java中默认线程有俩个, 一个是main主线程, 一个是GC线程

• 每个进程都有独立的代码和内存(数据和上下文)，程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程(由同一个进程创建的线程)共享代码和进程数据，每个线程都有自己独立的运行栈和程序计数器（PC）, 但它没有共享的堆，线程之间切换的开销小。

• 如果一个进程内有多个线程，这些线程的执行过程不是一条线的，而是多条线（线程）共同完成的；线程可以算是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

• 同一进程的线程共享本进程的地址空间和资源，而进程之间和线程之间的地址空间和资源是相互独立的。

• 在Windows中进程终止会等待自己所有的线程都结束后, 进程才会结束

• 如果子线程的崩溃是由于自己的一亩三分地引起的，那就不会对主线程和其他子线程产生影响，但是如果子线程的崩溃是因为对共享区域造成了破坏，那么大家就一起崩溃了。

如果进程不屏蔽 segment fault 信号，一个线程崩溃，所有线程终结。

如果屏蔽 segment fault 信号，且线程崩溃的位置是线程私有位置（stack），那么其他线程没有问题。

如果屏蔽 segment fault 信号，且线程崩溃的位置是线程共享位置（heap、全局变量等），那么其他线程也会出现问题。

• 每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。

• 进程的通信方式有无名管道, 有名管道, 消息队列, 信号量, 共享内存, socket

• 线程之间的通信字节和字符管道, notify, wait这些方法

线程的状态

---

// 初始状态, 新生状态

NEW,

// 运行状态, 就绪状态, 正在执行或者在就绪队列等待

RUNNABLE,

// 阻塞状态

BLOCKED,

// 等待, 比如执行了wait方法, 在死死的等待

WAITING,

// 等待, 但是限时等待

TIMED_WAITING,

// 销毁

TERMINATED;

//让出cpu但是不改变其本身状态

yield;

wait和sleep的对比

---

• 一个的object的方法, 一个是thread的方法

• wait会释放锁, sleep不会释放锁, 可以理解为sleep是抱着锁睡觉

• 使用的地方不同, wait必须在synchronized内部使用, sleep随意

Synchronized和Lock对比

---

• synchronized是一个关键字, lock是一个接口

• lock是非常灵活的, synchronized很笨重

• synchronized无法判断锁的状态, lock可以判断

• synchronized执行完同步代码块会自动释放锁, lock必须执行unlock

• synchronized线程1或得锁, 线程2必须死死等待, lock可以使用trylock

• synchronized可重入,非公平的, lock可重入, 公平性是可以设置的, (公平就是支持先进先出, 非公平就是不保证先进先出)

• synchronized适合少量同步代码使用, lock适合大量同步代码使用

• lock中有ReentrantLock和readlock和writelock

• synchronized锁的是对象, 无论是实例对象还是类对象, ReentrantLock结合condition锁的是一个具体的condition

• synchronized中的使用wait和notify, condition使用await和signal

• synchronized中使用的notify随意唤醒一个线程, notifyAll是唤醒所有线程, 而condition可以实现指定线程去唤醒

• synchronized基于对象的markword中的标志位和一个基于CAS操作的等待队列实现, 而lock中的比如ReentrantLock是基于AQS实现

• synchronized的底层也是一个基于CAS操作的等待队列，但JVM实现的更精细，把等待队列分为waie_SET和EntryList，目的是为了提高线程的出列速度；当然也实现了偏向锁，从数据结构来说二者设计没有本质区别。但synchronized还实现了自旋锁，并针对不同的系统和硬件体系进行了优化，而Lock则完全依靠系统阻塞挂起等待线程。

synchronized实现生产者消费者和lock实现生产者消费者

---

package com.lock;

import java.util.Date;

/**

• Created with IntelliJ IDEA.

• Description: If you don’t work hard, you will be a loser.

• User: Listen-Y.

• Date: 2020-12-02

• Time: 18:49

*/

public class Syn {

public static void main(String[] args) {

Data data = new Data();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.put();

}

}, “A”).start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.put();

}

}, “B”).start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.take();

}

}, “C”).start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.take();

}

}, “D”).start();

}

}

class Data {

private int date = 0;

public synchronized void put(){

while (date != 0) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println(Thread.currentThread().getName() + “:” + date);

date++;

this.notifyAll();

}

public synchronized void take(){

while (date == 0) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println(Thread.currentThread().getName() + “:” + date);

date–;

this.notifyAll();

}

}

package com.lock;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

• Created with IntelliJ IDEA.

• Description: If you don’t work hard, you will be a loser.

• User: Listen-Y.

• Date: 2020-12-02

• Time: 19:05

*/

public class BetterSyn {

public static void main(String[] args) {

Data3 data = new Data3();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.show1();

}

}, “A”).start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

data.show2();

}

}, “B”).start();