Java 多线程（一）
参考教程：B站狂神说Java
线程创建方式
1. 实现重写Thread类的run方法或实现Runnable接口的run方法
通过Thread类的源码可知，Thread类实现了Runnable接口，因此本质都是Runnable的run方法。而Thread实现的run方法所调用的为成员变量Runnable target的run方法，该对象可以通过Thread的构造方法传递一个已实现的Runnable接口，如果不传递则默认为null。
public class Thread implements Runnable {
private Runnable target;
public void run() {
if (this.target != null) {
this.target.run();
}
}
}
线程开启代码
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "启动");
}, "线程A").start();
2. 实现Callable接口
使用Callable接口也可以实现线程创建，但是线程启动需要调用Thread的start方法，因此Callable需要现与Thread产生关联，而FutureTask正好满足了这一点。FutureTask实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable接口，因此FutureTask既是Callable的实现类，也是Runnable的实现类，我们只需要把实现好的Callable放进FutureTask中，然后把FutureTask传递给Thread来执行就好。而Callable的底层实际为在Runnable接口的run方法中调用了call方法
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println(Thread.currentThread().getName() + "启动");
return Thread.currentThread().getName() + "执行完毕";
}
}
与Runnable的run方法不同，Callable的call方法可以抛出异常，且有一个返回值，可以通过futureTask.get()获取这个返回值，不过根据call方法的执行时间，futureTask.get()方法为获取线程的返回值可能产生阻塞。
MyThread myThread = new MyThread();
FutureTask futureTask = new FutureTask(myThread);
new Thread(futureTask, "线程B").start();
System.out.println(futureTask.get());
需要注意的是，java本身是不能开启线程的，在Thread的start方法中，通过调用本地方法start0方法开启线程，即通过JVM调用底层C/C++的代码开启线程
public synchronized void start() {
if (this.threadStatus != 0) {
throw new IllegalThreadStateException();
} else {
this.group.add(this);
boolean var1 = false;
try {
this.start0();
var1 = true;
} finally {
try {
if (!var1) {
this.group.threadStartFailed(this);
}
} catch (Throwable var8) {}
}
}
}
private native void start0();
锁
1. Synchronized锁
Synchronized为一个java关键字，能对一个对象进行加锁解锁，使多线程下代码有同步的效果，作用在方法以及代码块上
public synchronized void test1() {
System.out.println(Thread.currentThread().getName() + "=========>hello");
}
public void test2() {
synchronized (this){
System.out.println(Thread.currentThread().getName() + "=========>hello");
}
}
2. Lock锁
Lock为java.util.concurrent即JUC包下的一个类，可以通过lock和unlock方法进行加锁以及解锁
Lock lock = new ReentrantLock();
public void test3(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "=========>hello");
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
3. Synchronized锁与Lock锁的区别
-
Synchronized为java的关键字；Lock为一个java类
-
Synchronized会自动加锁解锁；Lock需要手动进行加锁解锁，如果解锁后没有解锁可能产生死锁
-
获得Synchronized锁的线程如果发生阻塞，其他等待这个锁的线程也会进入阻塞一直等待直到能获取锁；
Lock可以通过tryLock方法尝试获取锁，无论是否能获取都会退出方法继续执行，而非等待阻塞
-
Synchronized锁为不公平锁；Lock锁默认为不公平锁，但可以设置
-
方法上Synchronized锁的对象为当前对象的引用，普通方法为调用这个方法的对象，静态方法为该类的Class对象；锁代码块的Synchronized锁的为括号中的对象
Lock锁锁的是Lock本身这个对象的引用
-
Synchronized使用Object类的wait和notify进行阻塞唤醒；Lock使用Condition类的await和signal进行阻塞唤醒
sleep和wait的区别
- sleep为Thread的方法；wait为Object类的方法
- sleep可以在任意代码用执行；wait只能带同步代码块中执行，对应的notify也同样
- sleep必须指定线程睡眠的时间；wait可以指定也可以不指定，同时可以使用notify通知唤醒
- sleep睡眠过程中，线程不会释放已获得的锁；wait等待阻塞过程中，会释放已获得的锁
生产者消费者问题
假设现有一个类，定义一个int型的number，初始值为0，以及有一个生产方法使number在等于0时会加1，一个消费方法使number大于0时会-1。
现有若干生产者及消费者同时进行生产和消费(多线程)，需要保证生产消费有序进行，即线程每次执行number的结果010101以此类推。
1. Synchronized版
public class Test {
public static void main(String[] args) {
Resource resource = new Resource();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "生产者A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "消费者A").start();
}
}
class Resource{
private int number = 0;
public synchronized void produce() throws InterruptedException {
if (number != 0)
wait();
number++;
System.out.println(Thread.currentThread().getName() + "完成生产，number为：" + number);
notifyAll();
}
public synchronized void consume() throws InterruptedException {
if (number == 0)
wait();
number--;
System.out.println(Thread.currentThread().getName() + "完成消费，number为：" + number);
notifyAll();
}
}
//结果
//生产者A完成生产，number为：1
//消费者A完成消费，number为：0
//生产者A完成生产，number为：1
//消费者A完成消费，number为：0
//生产者A完成生产，number为：1
//消费者A完成消费，number为：0
需要注意，这种实现并不安全，当线程增加时可能会出现虚假唤醒，导致结果无序，比如以下情况
Resource resource = new Resource();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "生产者A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "生产者B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "消费者A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resource.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "消费者B").start();
运行结果的一部分：
生产者B完成生产，number为：1
生产者A完成生产，number为：2
生产者B完成生产，number为：3
消费者B完成消费，number为：2
消费者B完成消费，number为：1
消费者B完成消费，number为：0
消费者A完成消费，number为：-1
消费者A完成消费，number为：-2
消费者A完成消费，number为：-3
虚假唤醒：在上面有提到，在wait等待阻塞时，线程会释放已获得的锁，因此会有多个线程进入方法，并都处于等待阻塞状态。此时消费者完成消费，并通知唤醒所有线程，此时生产者由于使用if检查number的值，因此所有生产者都被唤醒后，会直接进行生产使number+1，导致生产消费无序。
改进：只需把if判断改为while即可，这样只要有一个生产者进行生产，其他生产者会继续判断需不需要进行生产，若number不为0则重新进入阻塞状态
class Resource{
private int number = 0;
public synchronized void produce() throws InterruptedException {
while (number != 0)
wait();
number++;
System.out.println(Thread.currentThread().getName() + "完成生产，number为：" + number);
notifyAll();
}
public synchronized void consume() throws InterruptedException {
while (number == 0)
wait();
number--;
System.out.println(Thread.currentThread().getName() + "完成消费，number为：" + number);
notifyAll();
}
}
2. Lock版
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void produce() {
lock.lock();
try {
while (number != 0)
condition.await();
number++;
System.out.println(Thread.currentThread().getName() + "完成生产，number为：" + number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void consume() {
lock.lock();
try {
while (number == 0)
condition.await();
number--;
System.out.println(Thread.currentThread().getName() + "完成消费，number为：" + number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}