java中的多线程：线程使用、线程安全、线程通信

Runnable：

---

Runnable是一个函数式接口：

@FunctionalInterface

public interface Runnable {

public abstract void run();

}

复制代码

Runnable不利于线程重用管理

Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println(“Thread with Runnable started!”);

}

};

Thread thread = new Thread(runnable);

thread.start();

复制代码

ThreadFactory：

---

ThreadFactory factory = new ThreadFactory() {

int count = 0;

@Override

public Thread newThread(Runnable r) {

count ++;

return new Thread(r, “Thread-” + count);

}

};

Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + “started!”);

}

};

Thread thread = factory.newThread(runnable);

thread.start();

Thread thread1 = factory.newThread(runnable);

thread1.start();

复制代码

Executor线程池：

---

Executor线程池（最为推荐）：

Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println(“Thread with Runnable started!”);

}

};

Executor executor = Executors.newCachedThreadPool();

executor.execute(runnable);

executor.execute(runnable);

executor.execute(runnable);

复制代码

Callable 和 Future：

---

Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。

@FunctionalInterface

public interface Callable {

V call() throws Exception;

}

复制代码

Callable和Future一般成对出现，future.get()获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

Callable callable = new Callable() {

@Override

public String call() {

try {

Thread.sleep(1500);

} catch (InterruptedException e) {

e.printStackTrace();

}

return “Done!”;

}

};

ExecutorService executor = Executors.newCachedThreadPool();

Future future = executor.submit(callable);

try {

String result = future.get();

System.out.println("result: " + result);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

复制代码

线程安全和线程同步

=========

线程安全：指函数在多线程环境中被调用时，能够正确地处理多个线程之间的全局变量，使得功能正确完成。

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作。

线程同步不等于线程安全，现在很多人误解了这一点而喜欢将他们混为一谈。现实是，当我询问面试者何为线程同步时，很多人回答的都是线程安全。

线程同步是实现线程安全的一种手段，你当然也可以用其他的方式达到线程安全。

Threadsafe vs Synchronized

线程安全的本质问题是资源问题：

当一个共享资源被一个线程读操作时，该资源不能被其他线程任意写；

当一个共享资源被一个线程写操作时，该资源不能被其他线程任意读写；

下面介绍java中实现线程安全的几种方式：

synchronized

---

synchronized以同步方式保证了方法内部或代码块内部资源(数据)的互斥访问，保证了线程之间对监视资源的数据同步.

private synchronized void count(int newValue) {

x = newValue;

System.out.println("x= " + x);

}

复制代码

另一种写法：

private void count(int newValue) {

synchronized (this) {

x = newValue;

System.out.println("x= " + x);

}

}

复制代码

volatile

---

volatile关键字修饰的变量具有原子性和同步性，相当于实现了对单⼀字段的线程间互斥访问。

volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

volatile可以看做是简化版的 synchronized.

volatile 只对基本类型 (byte、char、short、int、long、float、double、boolean)的赋值操作和对象的引⽤赋值操作有效。

java.util.concurrent.atomic:

---

AtomicInteger、AtomicBoolean 等类，作⽤和 volatile 基本⼀致，可以看做是 volatile修饰的Integer、Boolean等类。

Lock / ReentrantReadWriteLock

---

Lock同样是加锁机制，但使⽤⽅式更灵活，同时也更麻烦：

Lock lock = new ReentrantLock();

…

lock.lock();

try {

x++;

} finally {

lock.unlock();

}

复制代码

Synchronized存在的一个性能问题就是读与读之间互斥，所以我们⼀般并不会只是使⽤ Lock ，⽽是会使⽤更复杂的锁，例如 ReadWriteLock ，从而进行一些更加细致化的操作，如下代码：

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

Lock readLock = lock.readLock();

Lock writeLock = lock.writeLock();

private int x = 0;

private void writeOperate () {

writeLock.lock();

try {

x++;

} finally {

writeLock.unlock();

}

}

private void readOperate ( int time){

readLock.lock();

try {

System.out.println();

} finally {

readLock.unlock();

}

}

复制代码

读取锁是共享的，因而上述代码中，有线程写操作时，其他线程不可写，不可读；该线程读操作时，其他线程不可写，但可读。

线程间通信/交互

========

线程有自己的私有空间，但当我多个线程之间相互协作的时候，就需要进行线程间通信方，本节将介绍Java线程之间的几种通信原理。

锁与同步

---

这种方式主要是对全局变量加锁，即用synchronized关键字对对象或者代码块加锁lock，来达成线程间通信。

这种方式可详见上一节线程同步中的例子。

等待/通知机制

---

基于“锁”的方式需要线程不断去尝试获得锁，这会耗费服务器资源。

Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的，

wait()方法和notify()方法必须写在synchronized代码块里面：

wait()和notify()方法必须通过获取的锁对象进行调用，因为wait就是线程在获取对象锁后，主动释放对象锁，同时休眠本线程，直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作，因而必须放在加锁的synchronized代码块环境内。

notify()方法会随机叫醒一个正在等待的线程，而notifyAll()会叫醒所有正在等待的线程，被唤醒的线程重新在就绪队列中按照一定算法最终再次被处理机获得并进行处理，而不是立马重新获得处理机。

public class mythread {

private static Object lock = new Object();

static class ThreadA implements Runnable {

@Override

public void run() {

synchronized (lock) {

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

try {

System.out.println("ThreadA: " + i);

lock.notify();

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

lock.notify();

}

}

}

static class ThreadB implements Runnable {

@Override

public void run() {

synchronized (lock) {

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

try {

System.out.println("ThreadB: " + i);

lock.notify();

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

lock.notify();

}

}

}

public static void main(String[] args) {

new Thread(new ThreadA()).start();

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

e.printStackTrace();

}

new Thread(new ThreadB()).start();

}

}

复制代码

join方法

---

join()方法让当前线程陷入“等待”状态，等join的这个线程执行完成后，再继续执行当前线程。

当主线程创建并启动了耗时子线程，而主线程早于子线程结束之前结束时，就可以用join方法等子线程执行完毕后，从而让主线程获得子线程中的处理完的某个数据。

join()方法及其重载方法底层都是利用了wait(long)这个方法。

public class mythread {

static class ThreadA implements Runnable {

@Override

public void run() {

try {

System.out.println(“子线程睡一秒”);

Thread.sleep(1000);

System.out.println(“子线程睡完了一秒”);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) throws InterruptedException {

Thread thread = new Thread(new ThreadA());

thread.start();

thread.join();

System.out.println(“如果不加join方法，这行就会先打印出来”);

}

}

复制代码

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
oin();

System.out.println(“如果不加join方法，这行就会先打印出来”);

}

}

复制代码

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-uopk8xbA-1715720282348)]

[外链图片转存中…(img-WDMiMgYh-1715720282348)]

[外链图片转存中…(img-hUDWYQd4-1715720282349)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！