Thread：

Thread thread = new Thread() {

@Override

public void run() {

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

}

};

thread.start();

复制代码

Thread类的几个常用的方法：

• sleep()：静态方法，使当前线程睡眠一段时间；

• currentThread()：静态方法，返回对当前正在执行的线程对象的引用；

• start()：开始执行线程的方法，java虚拟机会调用线程内的run()方法；

• join()：使当前线程等待另一个线程执行完毕之后再继续执行，内部调用的是Object类的wait方法实现的；

• yield()：yield意为放弃，yield()方法指当前线程愿意让出对当前处理器的占用。需要注意，即时当前线程调用了yield()方法让出处理机，调度时也有可能继续让该线程竞争获得处理机并运行；

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();

hread.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();
[外链图片转存中…(img-1aEuGrwM-1635177119837)]