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!”;
}
};
ExecutorServ Java开源项目【ali1024.coding.net/public/P7/Java/git】 ice 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.printS 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》开源 tackTrace();
}
}
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();
}
最后
终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化
) {
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();
}
最后
终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化
[外链图片转存中…(img-kaeTdJp6-1650518902732)]
183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
