在进行多线程的内容之前我们需要首先了解涉及操作系统的几个知识点。
概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。
内存结构：
进程可以细化为多个线程。 每个线程，拥有自己独立的：栈、程序计数器 多个线程，共享同一个进程中的结构：方法区、堆。
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事
当我们在进行商品抢购的时候，在支付按钮上总是有个计时器在进行倒计时，但是我们此时仍然可以进行商品信息的查看，这个计时器和我们浏览商品信息的线程是同时进行的，这样也就实现了抢购场景，增加了用户的体验。
Java语言的JVM允许程序运行多个线程，它通过 java. lang.Thread类来体现
每个线程都是通过某个特定 Thread对象的run（方法来完成操作的，经常把run()方法的主体称为线程体 通过该 Thread对象的 start（方法来启动这个线程，而非直接调用run
注意点：
代码示例
//1.继承Thread类
class MyThread extends Thread {
public MyThread() {
}
//2.重run方法
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.新建Thread对象
MyThread myThread = new MyThread();
//4.调用start方法
myThread.start();
}
}
代码示例：
//1. 创建一个实现了Runnable接口的类
public class RunnableTest implements Runnable {
// 2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
class test {
public static void main(String[] args) {
//3. 创建实现类的对象
RunnableTest runnableTest = new RunnableTest();
//4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread thread = new Thread(runnableTest);
//5. 通过Thread类的对象调用start()
thread.start();
}
}两种方式的对比：
开发中优先选择：实现Runnable接口的方式
原因：
?2. 实现的方式更适合来处理多个线程共享数据的情况。
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。 目前两种方式，要想启动线程，都是调用的Thread类中的start()。
也可以采用创建匿名类的方式
public class ThreadDemo {
public static void main(String[] args) {
//创建Thread类的匿名子类的方式
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
}
}start():启动当前线程；调用当前线程的run()，只有Thread类和他的子类才能调用start()方法
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread():静态方法，返回执行当前代码的线程
getName():获取当前线程的名字
setName():设置当前线程的名字
yield():释放当前cpu的执行权
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop():已过时。当执行此方法时，强制结束当前线程。
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive():判断当前线程是否存活
获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。
线程通信：wait() / notify() / notifyAll() :此三个方法定义在Object类中的。
线程的分类
线程的五种状态：
说明：
生命周期关注两个概念：状态、相应的方法
关注：状态a-->状态b:哪些方法执行了（回调方法） 某个方法主动调用：状态a-->状态b
阻塞：临时状态，不可以作为最终状态
死亡：最终状态。
例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式
在Java中，我们通过同步机制，来解决线程的安全问题。
synchronized(同步监视器){//同步监视器就是需要同步线程的公共对象
//需要被同步的代码
}说明：
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
代码示例：
继承Runnable接口形式同步代码块
public class Ticket implements Runnable {
private int tick = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
if (tick > 0) {
System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
} else {
break;
}
}
}
}
}
class TicketTest {
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread thread1 = new Thread(ticket);
Thread thread2 = new Thread(ticket);
Thread thread3 = new Thread(ticket);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}继承Thread类形式同步代码块
public class Ticket2 extends Thread {
private static int tick = 100;
private static Object object = new Object();
public Ticket2() {
}
@Override
public void run() {
while (true) {
synchronized (object) {
//synchronized (Ticket2.class) {//通过反射调用当前类
if (tick > 0) {
System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为" + tick--);
} else {
break;
}
}
}
}
}
class TicketTest2 {
public static void main(String[] args) {
Ticket2 ticket1 = new Ticket2();
Ticket2 ticket2 = new Ticket2();
Ticket2 ticket3 = new Ticket2();
ticket1.setName("窗口1");
ticket2.setName("窗口2");
ticket3.setName("窗口3");
ticket1.start();
ticket2.start();
ticket3.start();
}
}如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
public synchronized void show(String namer){
....
}代码示例：
public class Ticket3 implements Runnable {
private int tick = 100;
private boolean isFlag = true;
@Override
public void run() {
while (isFlag) {
show();
}
}
public synchronized void show() {//同步show方法，继承Thread类方法一样，只需同步方法即可，同时需要给方法加static关键字，确保不会创建多个对象
if (tick > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
} else {
isFlag = false;
}
}
}
class TicketTest3 {
public static void main(String[] args) {
Ticket3 ticket = new Ticket3();
Thread thread1 = new Thread(ticket);
Thread thread2 = new Thread(ticket);
Thread thread3 = new Thread(ticket);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}class A {
//1.实例化ReentrantLock对象
private final ReenTrantLock lock = new ReenTrantLook();
public void m (){
lock.lock//2.先加锁
try{
//保证线程同步的代码
}finally{
lock.unlock();//3.后解锁
}
}
}
//注意：如果同步代码块有异常，要将unlock()写入finally语句块中代码示例：
class Window implements Runnable{
private int ticket = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
//2.调用锁定方法lock()
lock.lock();
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
ticket--;
}else{
break;
}
}finally {
//3.调用解锁方法：unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}在《 Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他仼务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
synchronized的锁是什么：
注意点：
如何找问题，即代码是否存在线程安全？（非常重要）
（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多线程运行代码中是否有多条语句操作共享数据
如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。 即所有操作共享数据的这些语句都要放在同步范围中
注意点：
范围太小：没锁住所有有安全问题的代码 范围太大：没发挥多线程的功能。
相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）
使用的优先顺序：
Lock---> 同步代码块（已经进入了方法体，分配了相应资源 ) --->同步方法（在方法体之外)
利弊： 同步的方式，解决了线程的安全问题。---好处 操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
利用同步锁的方式，有三种方式同步代码块、同步方法和用lock方法
相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）
死锁的理解： 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
说明：
出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
我们使用同步时，要避免出现死锁。
死锁举例：
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}为了解决线程的死锁问题，引入线程通讯
wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
否则，会出现IllegalMonitorStateException异常
wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
代码示例：
使用两个线程打印 1-100，线程1, 线程2 交替打印。
class MyThread implements Runnable {
private int number = 1;
private Object object = new Object();
@Override
public void run() {
while (true) {
synchronized (object) {
object.notify();//调用notify()方法唤醒线程
if (number <= 100) {
//线程休眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + number);
number++;
try {
object.wait();//打印输出一次后调用wait()方法将线程阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread thread1 = new Thread(myThread);
Thread thread2 = new Thread(myThread);
thread1.setName("线程1:");
thread2.setName("线程2:");
thread1.start();
thread2.start();
}
}sleep() 和 wait()的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
实现方法：
创建一个实现Callable的实现类
实现call方法，将此线程需要执行的操作声明在call()中
创建Callable接口实现类的对象
将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
获取Callable中call方法的返回值
代码示例：
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程对性能影响很大。
解决方案：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
实现方法：
相关API：
JDK 5.0起提供了线程池相关AP|： Executor Service和 Executors
Executor Service：真正的线程池接口。常见子类 Thread Poolexecutor
void execute(Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable
<T> Future<T> submit（Callable<T>task）：执行任务，有返回值，一般又来执行Callable
void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors. newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFⅸedthreadPool(n)；创建一个可重用固定线程数的线程池
EXecutors. newSingleThreadEXecutor()：创建一个只有一个线程的线程池
Executors. new thread Poo(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。代码示例：
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}应用线程池的好处：
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
面试题：Java中多线程的创建有几种方式？四种。
JDK 5.0以前：
JDK 5.0以后：
原文：https://www.cnblogs.com/blknemo/p/13846922.html