Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常 把run()方法的主体称为线程体
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
继承Thread类方式（这个在官方文档Tread类中有说明）
首先要创建一个继承于Thread类的子类
重写Thread类的run()方法 :将此线程执行的操作声明在run方法中
创建Thread类的子类的对象
通过此对象调用start()方法：它会启动一个线程，然后自动调用run()方法；不可以已经调用过start方法的线程再调用start。一个thread子类对象只能执行一次start
例子
//这也就是在主线程中创建一个线程 //例子：遍历100以内的偶数 class Mythread extends Thread { private static int share = 100; // 创建一个共享变量 @Override public void run() { for (int i = 0; i <10000; i++) {//这里的i要大一点，因为线程是轮转的， //数字太小在第一次分给这个线程的时间片内就足以把程序执行完毕，就体现不出是多线程在执行 if (i%2 == 0){ // 本来就是在这个线程之中声明的方法，这里面的方法默认就是调用this // 所以Thread.currentThread() 可以省略 System.out.println(Thread.currentThread().getName()+": " +i); } } } } public class ThreadTest { public static void main(String[] args) { Mythread mythread = new Mythread(); mythread.start(); //mythread.run(); 如果这样的话它不会创建线程，也就是run里面的代码就是在主线程中跑的 System.out.println("asdsad"); for (int i = 0; i <10000; i++) { if (i%2 == 0){ System.out.println(Thread.currentThread().getName()+": " +i); } } } }当我们写多了之后就可以这样的写：
public class ThreadTest { public static void main(String[] args) { new Thread(){ @Override public void run() { for (int i = 0; i <10000 ; i++) { System.out.println(Thread.currentThread().getName()); } } }.start(); }start() :启动当前线程，调用当前线程的run()
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
currentThread(): 静态方法返回执行，当前代码的线程。
getName() : 获取当前线程的名字
setName(): 设置当前线程的名字
yield():释放当前线程的执行权 （但可能在下一个时刻又是这个线程抢到了cpu）
join(): 在线程A中调用线程B的join方法，这时线程A就会进入阻塞状态(就算CPU想给你分配资源也没有用)，知道线程B完全执行完后，A才会结束阻塞状态
stop()：强制执行线程生命期结束，已经被弃用了，不建议使用。
sleep(long millis): 让当前线程阻塞指定的毫秒数
isAlive()：判断当前线程是否还存活
例子：
public static void main(String[] args) { new Thread(){ @Override public void run() { for (int i = 0; i <10000 ; i++) { Thread.currentThread().setName("线程0"); System.out.println(Thread.currentThread().getName()); if (i%20 == 0){ Thread.yield();// 释放当时线程cpu的执行权 //yield(); 质量不保证的，从java14开始就可能不支持了 } } } }.start(); System.out.println("asdsad"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i <10000 ; i++) { if (i%2 == 0){ System.out.println(Thread.currentThread().getName()+": " +i); } } }java线程的优先级分十个档次，高优先级的线程，被执行的概率比低优先级的线程的概率要高，并不意味着只有当高优先级的线程执行完后，低优先级才执行
/** * The minimum priority that a thread can have. */ public static final int MIN_PRIORITY = 1; /** * The default priority that is assigned to a thread. */ public static final int NORM_PRIORITY = 5; /** * The maximum priority that a thread can have. */ public static final int MAX_PRIORITY = 10;getPriority(): 获取线程的优先级
setPriority(int p):设置线程的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8L6hukPB-1603245836121)(/Users/luca/MarkText-img-Support/2020-07-17-11-34-20-image.png)]
步骤：
创建一个实现Runnalbe接口的类
实现Runnable中的抽象方法：run()
创建实现类的对象
将此对象传入Thread类的构造器中，创建Thread的对象
通过Thread类的对象调用start()方法
//1- 创建一个实现Runnalbe接口的类 class Mthread implements Runnable{ private int share =100; //创建一个线程共享变量 //2- 实现Runnable中的抽象方法：run() @Override public void run() { for (int i = 0; i <10000; i++) { if (i%2 == 0){ System.out.println(Thread.currentThread().getName()+": " +"priority: " + Thread.currentThread().getPriority() +i); } } } } public class ThreadRunnbaleTest { public static void main(String[] args) { //3- 创建实现类的对象 Mthread mthread = new Mthread();//我么这里只造了一个对象，所以share是被这两个线程共享的 //4- 将此对象传入Thread类的构造器中，创建Thread的对象 Thread thread = new Thread(mthread); //5- 通过Thread类的对象调用start()方法 thread.start(); } }开发中优先选择实现Runnable的方式：
java是单继承的，如果这个类继承了Thread类就不可以在继承别的类，这就会使我们这个类受到限制。而java是可以实现多个接口的， 所以使用实现Runnable接口不会出现这个问题
它更适合用来处理多线程共享数据的情况
二者的联系：
其实Thread的类也是继承了Runnable接口，Thread类也重写了Runnable接口中的run()，所以我们可以写一个类来继承Thread类，然后重写run()，本质上也就是重写了Runnable中的run()方法，或是直接写一个类来实现Runnable
两种方法都要重写run，将线程要执行的逻辑声明在run()方法中。
线程同步主要解决的就是线程安全问题。
操作共享数据的代码就是需要被同步的代码
同步监视器，俗称：锁。任意一个类的对象都可以充当锁。多个线程必须使用同一把锁。 最方便地，我么可以使用当前对象this，但要确保这个对象只new一次。
注意⚠️：不要用String常量，Integer，Long等基本的数据类型当同步监视器
注意⚠️： 加锁的对象一定要记得加一个final，我们不希望这个引用指向别的对象，synchronized其实就是看这个锁定的对象的Markword，一旦这个引用指向别的对象了，原来对象的Markword都找不到了，这肯定会出问题。
class MYthread implements Runnable { private int share = 0; //创建一个线程共享变量 final Object obj = new Object();//多个线程共用一个obj，将它来充当锁 @Override public void run() { synchronized (obj) {//使用synchronized来保证线程安全 for (int i = 0; i < 1000000; i++) { share += 1; } } } }如果操作共享数据的代码块完整的声明在一个方法中，我们不妨将此方法声明为同步的。
使用了synchronized 关键字修饰的方法就成为同步方法
synchronized方法中，如果是实现Runnable方法 默认使用this来充当同步监视器；如果是继承Thread类则是用当前类(myClass.class)来充当同步监视器
class MYthread1 implements Runnable { private int share = 0; @Override public void run() { show(); } private synchronized void show() { for (int i = 0; i < 1000000; i++) { share += 1; } } } public static void main(String[] args) { //3- 创建实现类的对象 com.luca.Mthread1 mthread = new com.luca.Mthread(); //我么这里只造了一个对象，所以share是被这两个线程共享的 //4- 将此对象传入Thread类的构造器中，创建Thread的对象 Thread thread = new Thread(mthread); //5- 通过Thread类的对象调用start()方法 thread.start(); //再启动一个线程 Thread thread1 = new Thread(mthread); thread1.start(); }上面的例子效率就会比较低：就算如果instance已经不为空了，但是大家还是要执行线程安全的代码，这样的效率就比较低。
public static Bank getInstanceFaster(){ if (instance == null) { if (instance == null) { if (instance == null) { instance = new Bank(); } } } return instance; }从JDK 5.0开始，Java提供了更强大的线程同步机制一 通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.utiLconcurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
例子
class mythread implements Runnable { private int share = 100; private ReentrantLock lock = new ReentrantLock(); @Override public void run() { try { lock.lock(); for (int i = 0; i < 10000; i++) { if (i % 2 == 0) { System.out.println(Thread.currentThread().getName() + ": " + "priority: " + Thread.currentThread().getPriority() + i); } } } finally { lock.unlock(); } } }同：都是用来解决线程安全的
异：synchronized在执行完相应的同步代码后会自动的释放同步监视器；Lock则需要手动启动Lock，使用完毕后要手动释放锁。Lock它放置的位置比较灵活
wait(): wait会使调用该方法的线程进入阻塞状态，并且会使该线程释放同步监视器
notify(): 唤醒被wait()方法阻塞的线程。如果有多个wait() 阻塞的线程，则唤醒优先级高的，总之它只会唤醒一个线程。但是调用notify的线程不会释放锁的，所以如果唤醒的线程与调用notify的线程用的是同一把锁，其实这个这个被唤醒的线程还是需要等这该线程执行完才能去抢锁。除非在notify后马上调用wait，把这个锁让出来给被唤醒的线程。
notifyAll()： 唤醒全部被wait()方法阻塞的线程；
说明：
上述三个方法必须使用在synchronized中，Lock中有其他的方法。
这三个方法的调用者是同步监视器。
上述三个方法是定义在Object类中
同：都会使调用这两个方法的线程进入阻塞状态
异：
因为wait() 涉及到线程之间的通信，所以必须由同步监视器来调用，所以它 必须在synchronized的代码快中调用。而sleep()没有相关的限制
sleep() 定义在thread类中，因为wait()是由同步监视器调用，而任何一个类都可以作为同步监视器，所以wait()得定义在Object中
wait()方法在阻塞线程后会释放线程的锁，而sleep()不会
与实现Runnable相比，Callable接口下定义的call() 的功能更加强大
相比run()方法，call()可以有返回值
call()方法可以抛出异常
Callable支持泛型
call()需要借助FutureTask类，来执行一些操作，比如获取返回结果
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它婚可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
