得益于计算机的时间片机制，每一个应用程序的都可以在一段很小的时间段内执行。相比于单线程串行执行，得不到时间片就停止执行，多线程当中线程1得不到时间片，线程2有可能得到，可以更多的完成任务。
还有一种场景，单线程要操作IO设备，但是IO设备一般都会有较多的等待，这段时间CPU处于空闲，空闲的CPU资源就被浪费了，如果能把资源让给另外一个需要CPU资源的线程，那就提高了任务完成的速率，让活干的更快。
线程：拿微信举例，微信相当于一个进程，在微信启动后，向操作系统索要了一些资源的使用权限，线程相当于微信里面的打工人，这些打工人有很多岗位，比如收发消息岗、转账岗、抢红包岗等等，这些具体的工作，微信创建出来很多线程去干。怎么样让这些打打工人又快又好的干活呢，接着往下看。
Thread类是JVM中用于管理线程的一个类，每一个线程都有唯一的一个Thread对象与之一一对应
package thread;
public class TestThread extends Thread {
@Override
public void run() {
System.out.println("我是一个线程，我的名字是："+Thread.currentThread().getName());
}
public static void main(String[] args) throws InterruptedException {
TestThread testThread = new TestThread();
testThread.start();
testThread.join();
}
}
常见构造方法
| 方法 | 说明 |
| Thread() | 创建线程对象 |
| Thread(Runnable target) | 使用 Runnable 对象创建线程对象 |
| Thread(String name) | 创建线程对象，并命名 |
| Thread(Runnable target, String name) | 使用 Runnable 对象创建线程对象，并命名 |
| Thread(ThreadGroup group, Runnable target) | 线程可以被用来分组管理，分好的组即使线程组 |
常见属性
| 属性 | 获取方法 |
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
自JAVA诞生，Runnable就已经存在了，如果一个线程类要实现 Runnable 接口，则这个类必须定义一个名为 run 的无参数方法。
实现了 Runnable 接口的类可以通过实例化一个 Thread 实例，并将自身作为目标传递来运行。
Runnable定义：
@FunctionalInterface
public interface Runnable {
public abstract void run();
}Runnable使用举例：
package thread;
public class TestThread implements Runnable {
@Override
public void run() {
System.out.println("我是一个线程，我的名字是：" + Thread.currentThread().getName());
}
public static void main(String[] args) throws InterruptedException {
TestThread testThread = new TestThread();
Thread thread = new Thread(testThread);
thread.start();
thread.join();
}
}
函数式写法，这是JDK1.8之后，对Runnable加上了@FunctionalInterface函数式接口的修饰，可以实现函数式编程，也叫Lambda表达式，想了解Lambda表达式可以参考Lambda、函数式接口、Stream 一次性全给你
package thread;
public class TestThread {
public static void main(String[] args) {
Runnable runnable = ()->{
System.out.println("我是一个线程，我的名字是" + Thread.currentThread().getName());
};
Thread thread = new Thread(runnable);
thread.start();
}
}
注意，是调用新 new 出来的 Thread 实例的start() 方法，不要调用run方法，虽然我们是重写Runnable的 run方法的。调用 run方法并没有创建线程的效果，而是直接在当前线程执行，就和执行一个普通类的普通方法一模一样。
为什么要调用 start()方法呢，我们看看 Thread的 start()方法实现中，其实是调用了一个名称为 start0()的 native 方法，native 方法就不是用 Java 实现的了，而是在 JVM 层面的实现。
这个start0方法的主要逻辑就是启动一个操作系统线程，并和 JVM 线程绑定，开辟一些空间来存储线程状态和上下文的数据，然后执行绑定的 JVM 线程（也就是我们实现了Runnable的类）的 run方法的代码块，从而执行我们自定义的逻辑。
其实Runnable并不是很完美，其不能返回值，不能抛出异常，所以有了Callable，来实现这些功能。
Callable定义
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}Callable使用举例：
package thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
public class TestCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = () -> {
int sum = 0;
for (int i = 0; i < 5; ++i) {
sum += i;
//TimeUnit.SECONDS.sleep(1);
throw new Exception("业务出现异常");
}
return sum;
};
FutureTask<Integer> integerFutureTask = new FutureTask<>(callable);
Thread thread = new Thread(integerFutureTask);
thread.start();
System.out.println("我是main线程");
Integer result = null;
try {
result = integerFutureTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
}catch (Exception e) {
System.out.println("处理异常："+e.getMessage());
e.printStackTrace();
}
System.out.println("最终运行结果为："+result);
}
}
本质上，Runnable和Callable只是Thread要执行的任务类，并且Runnable和Callable是函数式接口。在java中一个类只能继承一个父类，可以实现多个接口，Runnable和Callable方式的好处是可以规避类的单继承的限制；
Runnable和Callable之间的区别：
Callable实现的是call()方法，Runnable实现的是run()方法
Callable可以通过FutureTask对象获取返回值，而Runnable则没有返回值
Callable可以抛出异常，而Runnable不支持
Callable要搭配FutureTask一起使用
常见的有以下两种方式：
1、通过共享的标记来沟通
2、调用interrupe()方法来通知
示例1：
package thread;
public class ThreadDemo {
private static class MyRunnable implements Runnable {
public volatile boolean isQuit = false;
@Override
public void run() {
while (!isQuit) {
System.out.println(Thread.currentThread().getName()
+ ": 别管我，我忙着转账呢!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()
+ ": 啊！险些误了大事");
}
}
public static void main(String[] args) throws InterruptedException {
MyRunnable target = new MyRunnable();
Thread thread = new Thread(target, "李四");
System.out.println(Thread.currentThread().getName()
+ ": 让李四开始转账。");
thread.start();
Thread.sleep(10 * 1000);
System.out.println(Thread.currentThread().getName()
+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");
target.isQuit = true;
}
}示例2：
package thread;
public class ThreadDemo {
private static class MyRunnable implements Runnable {
@Override
public void run() {
// 两种方法均可以
// while (!Thread.interrupted()) {
while (!Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName()
+ ": 别管我，我忙着转账呢!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println(Thread.currentThread().getName()
+ ": 有内鬼，终止交易！");
break;
}
}
System.out.println(Thread.currentThread().getName()
+ ": 啊！险些误了大事");
}
}
public static void main(String[] args) throws InterruptedException {
MyRunnable target = new MyRunnable();
Thread thread = new Thread(target, "李四");
System.out.println(Thread.currentThread().getName()
+ ": 让李四开始转账。");
thread.start();
Thread.sleep(10 * 1000);
System.out.println(Thread.currentThread().getName()
+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");
thread.interrupt();
}
}重点说明下第二种方法：
1、通过 thread 对象调用 interrupt() 方法通知该线程停止运行
2、thread 收到通知的方式有两种：
1、如果线程调用了wait()/join()/sleep()方法而阻塞挂起，则以InterruptedException异常的方式通知，清楚中断标志。
2、否则，只是内部的中断标识被设置，需要手动判断，在判断上也有区别；thread.interrupted()判断当前线程的中断标志，清除中断标志；thread.currentThread().isInterruptd(),判断指定线程的中断标识是否被限制，不清除中断标志。
| 方法 | 说明 |
| public void interrupt() | 中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位 |
| public static boolean interrupted() | 判断当前线程的中断标志位是否设置，调用后清除标志位 |
| public boolean isInterrupted() | 判断对象关联的线程的标志位是否设置，调用后不清除标志位 |
package thread;
import java.util.concurrent.atomic.AtomicInteger;
public class TestJoin {
public static void main(String[] args) throws InterruptedException {
//原子整型
AtomicInteger atomicInteger = new AtomicInteger();
Thread thread = new Thread(() -> {
//五万次自增操作
for (int i = 0; i < 50000; i++) {
atomicInteger.getAndIncrement();
}
});
Thread thread2 = new Thread(() -> {
//五万次自增操作
for (int i = 0; i < 50000; i++) {
atomicInteger.getAndIncrement();
}
});
//启动线程
thread.start();
thread2.start();
//等待两个线程执行完成
thread.join();
thread2.join();
System.out.println(atomicInteger);
}
}
想要得到线程的执行结果，就要等待线程执行完毕，join方法可以等待线程执行完毕，这里值得说明的是：Java 中的多线程代码不会随着主线程的退出而退出，在JAVA中，所有的线程都是通过线程对象来创建和管理的，点一个JAVA应用程序启动时，至少有一个主线程在运行，当主线程启动并创建其他线程时，这些线程就成了独立的执行流，可以在主线程退出之后，继续执行，每个线程都有自己的生命周期，他们独立于主线程的运行状态。
与 Java 不同，C++ 中的多线程代码会随着主线程的退出而退出，这是因为 C++ 标准库对线程的处理方式与 Java 不同。C++ 的线程是基于操作系统的线程模型实现的，而不是像 Java 那样由虚拟机管理。当主线程退出时，C++ 运行时库会通知操作系统关闭所有线程。主线程退出意味着整个进程退出，所有线程都会被终止。
需要注意的是，无论是在 Java 还是在 C++ 中，如果某个线程持有资源（如文件句柄、数据库连接等），而其他线程仍在使用这些资源，那么这些资源并不会自动释放。这需要开发者在编写代码时正确管理资源，并确保适当地关闭或释放资源。
| 方法 | 说明 |
| public void join() | 等待线程结束 |
| public void join(long millis) | 等待线程结束，最多等 millis 毫秒 |
| public void join(long millis, int nanos) | 同理，但可以更高精度 |
| 方法 | 说明 |
| public static void sleep(long millis) throws InterruptedException | 休眠当前线程 millis 毫秒 |
| public static void sleep(long millis, int nanos) throws InterruptedException | 可以更高精度的休眠 |
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis());
Thread.sleep(3 * 1000);
System.out.println(System.currentTimeMillis());
}
}wait方法使当前线程停止运行。
1、wait()方法是Object类的方法，该方法是将当前线程放入到线程就绪队列中，在wait()方法之后停止运行，直到接到通知或者被中断为止。
2、wait()方法只能在同步方法中或同步代码块中调用，如果调用是没有适当的锁，或抛出异常。
3、wait()方法调用后，当前线程释放锁，知道其他线程调用此线程对象的notify()方法或是notifyAll()方法，当前线程被唤醒进入就绪状态。
4、wait((long timeout))让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法， 或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
使被wait的线程继续运行。
1、方法notify()也要在同步方法或者是同步代码块中被调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
2、在执行完notify()方法之后，当前线程不会马上释放锁，而是要等待当前线程执行完notify()之后的代码，也就是退出同步代码块之后再释放锁。
package thread;
public class TestNotify implements Runnable {
private boolean flag;
private Object obj;
public TestNotify(boolean flag, Object obj) {
super();
this.flag = flag;
this.obj = obj;
}
public void waitMethod() {
synchronized (obj) {
try {
while (true) {
System.out.println("wait()方法开始.. " +
Thread.currentThread().getName());
obj.wait();
System.out.println("wait()方法结束.. " +
Thread.currentThread().getName());
return;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void notifyMethod() {
synchronized (obj) {
try {
System.out.println("notify()方法开始.. " + Thread.currentThread().getName());
obj.notify();
System.out.println("notify()方法结束.. " + Thread.currentThread().getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
if (flag) {
this.waitMethod();
} else {
this.notifyMethod();
}
}
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
TestNotify waitThread = new TestNotify(true, object);
TestNotify notifyThread = new TestNotify(false, object);
Thread thread1 = new Thread(waitThread, "wait线程");
Thread thread2 = new Thread(notifyThread, "notify线程");
thread1.start();
Thread.sleep(1000);
thread2.start();
System.out.println("main方法结束!!");
}
}
此方法会唤醒所有的在等待中的线程，使其正常执行
package thread;
class TestNotifyAll implements Runnable {
private boolean flag;
private Object obj;
public TestNotifyAll(boolean flag, Object obj) {
super();
this.flag = flag;
this.obj = obj;
}
public void waitMethod() {
synchronized (obj) {
try {
while (true) {
System.out.println("wait()方法开始.. " +
Thread.currentThread().getName());
obj.wait();
System.out.println("wait()方法结束.. " +
Thread.currentThread().getName());
return;
}
} catch (Exception e) {e.printStackTrace();
}
}
}
public void notifyMethod() {
synchronized (obj) {
try {
System.out.println("notifyAll()方法开始.. " +
Thread.currentThread().getName());
obj.notifyAll();
System.out.println("notifyAll()方法结束.. " +
Thread.currentThread().getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override
public void run() {
if (flag) {
this.waitMethod();
} else {
this.notifyMethod();
}
}
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
TestNotifyAll waitThread1 = new TestNotifyAll(true, object);
TestNotifyAll waitThread2 = new TestNotifyAll(true, object);
TestNotifyAll waitThread3 = new TestNotifyAll(true, object);
TestNotifyAll notifyThread = new TestNotifyAll(false, object);
Thread thread1 = new Thread(waitThread1, "wait线程A");
Thread thread2 = new Thread(waitThread2, "wait线程B");
Thread thread3 = new Thread(waitThread3, "wait线程C");
Thread thread4 = new Thread(notifyThread, "notify线程");
thread1.start();
thread2.start();
thread3.start();
Thread.sleep(1000);
thread4.start();
System.out.println("main方法结束!!");
}
}
线程一共有6种状态。
线程间同步的含义是线程间对临界资源操作的合理性；那生产者和消费者模型举个例子，生产者生产三个资源，消费者就能消费三个资源，当资源不足时消费者要通知生产者生产资源消费者等待，生产完资源后生产者要通知消费者消费，生产者等待。
信号量：表示可用资源的数量，本质上就是一个计数器，比如停车场有100个车位，那么就只有100个资源，停进去一辆资源-1，出来一辆资源+1，当资源为0的时候，想进停车场就得等待
| 方法 | 说明 |
| semaphore.acquire() |
对资源-1 |
| semaphore.release() |
对资源+1 |
package thread;
import java.util.concurrent.Semaphore;
public class TestSemaphore {
//信号量
public static Semaphore semaphore = new Semaphore(3);
public void testSemaphoreFunc()
{
System.out.println("我的名字是："+Thread.currentThread().getName());
try {
semaphore.acquire();
System.out.println("成功获取到一个资源,我的名字是："+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("资源使用完毕,我的名字是："+ Thread.currentThread().getName());
semaphore.release();
}
public static void main(String[] args) throws InterruptedException {
TestSemaphore testSemaphore = new TestSemaphore();
for (int i = 0; i < 10; ++i) {
Thread thread = new Thread(() -> testSemaphore.testSemaphoreFunc());
thread.start();
thread.join();
}
//定义一个任务
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("我的ID是："+Thread.currentThread().getName());
try {
semaphore.acquire();
System.out.println("成功获取到一个资源,我的ID是："+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("资源使用完毕,我的ID是："+ Thread.currentThread().getName());
semaphore.release();
}
};
for (int i = 0; i < 10; ++i) {
Thread thread = new Thread(runnable);
thread.start();
thread.join();
}
}
}
修饰的共享变量，可以保证可见性。
可见性的含义：为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线程之间不能及时看到改变。
将共享变量用volatile修饰，线程对变量做了改变就能及时刷新进主内存中，保证变量可见性。
java中没有与C++中条件变量一样的工具，但是 Java 提供了等待/通知机制来实现类似的功能。这个机制是通过线程对象的 wait()、notify() 和 notifyAll() 方法来实现的。
参考另一篇文章，待续。