创建子类，继承自Thread并且重写run方法：
class MyThread extends Thread {
@Override
public void run() {
System.out.println("hello thread");
}
}
public class Demo1 {
public static void main(String[] args) {
// 最基本的创建线程的办法.
Thread t = new MyThread();
//调用了start方法才是真正的在系统中创建了线程，执行run方法
t.start();
}
}创建一个类，实现Runnable接口再创建Runnable是实例传给Thread
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("hello");
}
}
public class Demo3 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start();
}
}
匿名内部类:
创建了一个匿名内部类，继承自Thread类，同时重写run方法，再new出匿名内部类的实例
public class Demo4 {
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println("hello");
}
};
t.start();
}
}new的Runnable，针对这个创建的匿名内部类，同时new出的Runnable实例传给Thread的构造方法
public class Demo5 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
t.start();
}
}lambda表达式 lambda代替Runnable
public class Demo6 {
public static void main(String[] args) {
Thread t = new Thread(() ->{
System.out.println("hello");
});
t.start();
}
}run和start的区别:run单纯的只是一个普通方法描述了任务的内容 start则是一个特殊的方法，内部会在系统中创建线程
线程停下来的关键是要让对应run方法执行完，对于main线程来说main方法执行完了才会终止
在线程中控制这个标志位就能影响到这个线程结束，但是此处多个线程共用一片虚拟空间，因此main线程修改的isQuit和t线程判断的isQuit是同一个值
public class Demo10 {
// 通过这个变量来控制线程是否结束.
private static boolean isQuit = false;
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (!isQuit) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
// 就可以在 main 线程中通过修改 isQuit 的值, 来影响到线程是否退出
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// main 线程在 5s 之后, 修改 isQuit 的状态.
isQuit = true;
}
}Thread.interruted()这是一个静态方法 Thread.currentThread().isInterrupted()这是一个实例方法，其中currentThread能够获取到当前线程的实例
public class Demo7 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
// 当触发异常之后, 立即就退出循环~
System.out.println("这是收尾工作");
break;
}
}
});
t.start();
try{
Thread.sleep(5000);
}catch (InterruptedException e){
e.printStackTrace();
}
// 在主线程中, 调用 interrupt 方法, 来中断这个线程.
// t.interrupt 的意思就是让 t 线程被中断!!
t.interrupt();
}
}需要注意的是调用这个方法t.interrupt()可能会产生两种情况：
多个线程之间调度顺序是不确定的，有时候我们需要控制线程之间的顺序，线程等待就是一种控制线程执行顺序的手段，此处的线程等待只要是控制线程结束的先后顺序。
哪个线程中的join，哪个线程就会阻塞等待直到对应的线程执行完毕为止。
Thread.currentThread()
能够获取当前线程的应用，哪个线程调用的currentThread就获取到哪个线程的实例 对比this如下：
对于这个代码来说，通过继承Thread的方法来创建线程。此时run方法中直接通过this拿到的就是当前Thread的实例
public class Demo4 {
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
System.out.println(this.getName());
}
};
t.start();
}
}然而此处this不是指向Thread类型，而是指向Runnable，Runnable只是一个单纯的任务没有name属性，要想拿到线程名字只能通过Thread.currentThread()
public class Demo5 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
//err
//System.out.println(this.getName());
//right
System.out.println(Thread.currentThread().getName());
}
});
t.start();
}
}针对系统层面：
java中Thread类进一步细化：
状态转换图：
定义：操作系统中线程调度是随机的，导致程序的执行可能会出现一些bug。如果因为调度随机性引入了bug线程就是不安全的，反之则是安全的。
解决方法：加锁，给方法直接加上synchronized关键字，此时进入方法就会自动加锁，离开方法就会自动解锁。当一个线程加锁成功的时候，其他线程尝试加锁就会触发阻塞等待，阻塞会一直持续到占用锁的线程把锁释放为止。
synchronized public void increase() {
count++;
}线程不安全产生的原因：
内存可见性解决方法：
在java中每个类都是继承自Object，每个new出来的实例里面一方面包含自己安排的属性，另一方面包含了“对象头”即对象的一些元数据。加锁操作就是在这个对象头里面设置一个标志位。
使用synchronized的时候本质上是对某个“对象”进行加锁，此时的锁对象就是this。加锁操作就是在设置this的对象头的标志位，当两个线程同时尝试对同一个对象加锁的时候才有竞争，如果是两个线程在针对两个不同对象加锁就没有竞争。
class Counter{
public int count;
synchronized public void increase(){
count++;
}
}需要显示制定针对那个对象加锁（java中的任意对象都可以作为锁对象）
public void increase(){
synchronized(this){
count++;
}
}相当于针对当前类的类对象加锁,类对象就是运行程序的时候。class文件被加载到JVM内存中的模样。
synchronized public static void func(){
}或者
public static void func(){
synchronized(Counter.class){
}
}可重入锁就是同一个线程针对同一个锁，连续加锁两次，如果出现死锁就是不可重入锁，如果不会死锁就是可重入的。因此就把synchronized实现为可重入锁，下面的例子里啊连续加锁操作不会导致死锁。可重入锁内部会记录所被哪个线程占用也会记录加锁次数，因此后续再加锁就不是真的加锁而是单纯地把技术给自增。
synchronized public void increase(){
synchronized(this){
count++;
}
}死锁的四个必要条件（前三个都是锁本身的特点）
java线程类：
禁止编译器优化保证内存可见性，产生原因：计算机想执行一些计算就需要把内存的数据读到CPU寄存器中，然后再从寄存器中计算写回到内存中，因为CPU访问寄存器的速度比访问内存快很多，当CPU连续多次访问内存结果都一样，CPU就会选择访问寄存器。
JMM（Java Memory Model）Java内存模型
就是把硬件结构在java中用专业的术语又重新抽象封装了一遍。
寄存器，缓存和内存之间的关系
CPU从内存取数据太慢，因此把数据直接放到寄存器里来读，但寄存器空间太紧张于是又搞了一个存储空间，比寄存器大比内存小速度比寄存器慢比内存快称为缓存。寄存器和缓存统称为工作内存。
寄存器，缓存和内存之间的关系图
volatile和synchronized的区别
wait和notify
等待和通知处理线程调度随机性问题的，join也是一种控制顺序的方式更倾向于控制线程结束。wait和notify都是Object对象的方法，调用wait方法的线程就会陷入阻塞，阻塞到有线程通过notify来通知。
public class Demo9 {
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
System.out.println("wait前");
object.wait();
System.out.println("wait后");
}
}wait内部会做三件事;
因此想用wait/notify就得搭配synchronized
public class Demo9 {
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
synchronized (object){
System.out.println("wait前");
object.wait();
System.out.println("wait后");
}
}
}注意：wait notify都是针对同一对象来操作的，例如现在有一个对象o，有10个线程都调用了o.wait，此时10个线程都是阻塞状态。如果调用了o.notify就会把10个线程中的一个线程唤醒。而notifyAll就会把所有10个线程全都给唤醒，此时就会竞争锁。
