多线程编程

一： 两种实现方式：

1.继承Thread类重写run方法
2.继承Runnable接口重写run方法(通常用这种，java单继承的局限性，后期还想继承其他类会无从下手)

二：简单demo1（多线程模拟买票）

package 多线程;

public class BuyTicket {
    public static void main(String[] args) {
        TickThread tt = new TickThread();
        Thread t1 = new Thread(tt,"张三");
        Thread t2 = new Thread(tt,"李四");
        Thread t3 = new Thread(tt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}
class TickThread implements Runnable{
    private  int total = 10;
    @Override
    public void run() {
        while (total>=1) {
            total--;
            System.out.println(Thread.currentThread().getName() + "买了票，剩余" + total + "张");
        }
        System.out.println(Thread.currentThread().getName()+"发现售罄");
    }
}

由于资源没有加锁，导致数据异常问题

三 简单demo2（模拟龟兔赛跑）

package 多线程;

public class RunGame {
    public static void main(String[] args) {
        Runner rn = new Runner();
        Thread rabbit = new Thread(rn,"rabbit");
        Thread tortoise = new Thread(rn,"tortoise");
        rabbit.start();
        tortoise.start();

    }
}
class Runner implements Runnable{
    private int stage = 100;
    private String winner=null;
    @Override
    public void run() {
       for(int i=1;i<=100;i++){
           if(isOver(i)==true) {
               Thread.currentThread().interrupt();
               break;
           }

       }

    }
    boolean isOver(int step){
        if (winner!=null){
            return true;
        }else{
            if(step==100){
                System.out.println(Thread.currentThread().getName()+"胜利！");
                winner=Thread.currentThread().getName();
                return true;
            }else{
                System.out.println(Thread.currentThread().getName()+"->"+step);
                return false;
            }
        }
    }
}

三：线程五大状态：

1.新生

Thread rabbit = new Thread(rn,"rabbit");
Thread tortoise = new Thread(rn,"tortoise");

new 一个Thread后，将会分配线程所需的资源。

2.就绪

t.start();

调用start后，线程进入就绪等待队列，至于什么时候运行，CPU调度说的算。

3.运行

4.阻塞

wait() 不携带资源
sleep()携带资源

5.死亡

#run正常执行完毕，尽量不要调用stop去强行终止线程

四：join简单使用demo

 Thread worker1 = new Thread(()->{
            try {
                for(int i=0;i<5;i++){
                    Thread.sleep(1000);
                    System.out.println("睡了"+(i+1)+"秒");
                }

                System.out.println("睡了一会，工作完成了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"worker1");
        Thread worker2 = new Thread(()->{
            try {
                worker1.join();
                System.out.println("员工2开始工作");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"worker2");

        worker1.start();
        worker2.start();

五：yield与设置优先级

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
设置优先级只是具有较大的概率先执行，但不代表一定先执行。

六：线程同步

问题
现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。 比如：同一张卡，两个人都在取钱，确保准确无误的执行的话，就需要线程之间的同步。

    public void drawMoney2(int m){
        if(money-m<0){
            System.out.println("没钱了");
        }else{
            synchronized (this){
                if(money-m<0){
                    System.out.println("没钱了");
                }else{
                    money=money-m;
                    System.out.println("还剩"+money);
                }
            }
        }
    }

对同一个账户取钱，由于取钱的操作存在一定的时间，当你发现账号有100，你需要取60（足够取）的时候，你开始准备取钱;在你执行取钱（还没成功的时候），另一个人进来了，发现钱 还是100（因为你还没执行完毕），于是又进入取60的操作，你进来的时候钱是100，当你执行取钱的时候，其实钱已经变成上一个人取后的40了，因此你取完60后，钱就是负数了。
同步问题要明确锁谁：锁你们共同持有的acount账户：

 public void drawMoney2(int m){
        if(money-m<0){
            System.out.println("没钱了");
        }else{
            synchronized (this){
                if(money-m<0){
                    System.out.println("没钱了");
                }else{
                    money=money-m;
                    System.out.println("还剩"+money);
                }
            }
        }
    }

此处要执行一次dounble check：当你进来时发现钱已经不够了，就直接走了（此时不需要获取锁，避免无效的资源浪费），当你发现资源够，到你锁起来的时候，这段时候也是有可能有人捷足先登的（可以在 synchronized (this)前sleep模拟加锁的延迟），因此拿到锁后还要再判断一下资源是否在这个时间差内被改变了。

七：死锁问题：

一种多个资源抢夺下的循环等待导致谁都没法进行下一步。
模拟死锁的demo:

package 多线程;

import java.sql.SQLOutput;

public class DeadLockTest {
    public static void main(String[] args) {
        Resource r = new Resource();
        Thread t1=new Thread(r,"csz");
        Thread t2=new Thread(r,"lc");
        t1.start();
        t2.start();

    }
}
class Resource implements Runnable{
     Object key1=new Object();
     Object key2=new Object();

    @Override
    public void run() {
        try {
            getResource();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void getResource() throws InterruptedException {
        if(Thread.currentThread().getName()=="csz"){
            synchronized (key1){
                System.out.println(Thread.currentThread().getName()+"拿了第一把锁");
                Thread.sleep(5000);
                synchronized (key2){
                    System.out.println(Thread.currentThread().getName()+"我进去了");
                }
            }
        }else{
            synchronized (key2){
                System.out.println(Thread.currentThread().getName()+"拿了第二把锁");
                Thread.sleep(5000);
                synchronized (key1){
                    System.out.println(Thread.currentThread().getName()+"我进去了");
                }
            }
        }


    }
}

需要两把锁进一间房，两个进程拿到了不一样的锁，都在等另一把锁。
解决办法:同一个代码块，不要同时持有两个对象锁!

 public void getResource() throws InterruptedException {
        if(Thread.currentThread().getName()=="csz"){
            synchronized (key1){
                System.out.println(Thread.currentThread().getName()+"拿了第一把锁");

            }
            synchronized (key2){
                System.out.println(Thread.currentThread().getName()+"我进去了");
            }
        }else{
            synchronized (key2){
                System.out.println(Thread.currentThread().getName()+"拿了第二把锁");

            }
            synchronized (key1){
                System.out.println(Thread.currentThread().getName()+"我进去了");
            }
        }
    }

七：线程并发（生产者消费者模式)

package 多线程;
public class ProductionAndConsumption {
    public static void main(String[] args) {
        WareHouse w=new WareHouse();
        Producter p=new Producter(w);
        Consumer c=new Consumer(w);
        new Thread(p,"生产者").start();
        new Thread(c,"消费者").start();
    }
}
class Producter implements Runnable{
    WareHouse warehouse;

    public Producter(WareHouse ware){
        this.warehouse=ware;
    }
    @Override
    public void run() {
            while(true) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    warehouse.product();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
}
class Consumer implements Runnable{
    WareHouse warehouse;
    public Consumer(WareHouse ware){
        this.warehouse=ware;
    }
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                warehouse.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
class WareHouse{
    public int total=5;
    public int size=10;

    public synchronized void product() throws InterruptedException {
            if (total<size) {
                total++;
                System.out.println(Thread.currentThread().getName() + "生产了一个,库存"+total+"个");
                this.notify();
            } else {
                System.out.println("库存满了生产者休息");
                wait();
            }
    }
    public synchronized void consume() throws InterruptedException {
        if(total==0){
            System.out.println("消费者在等");
     this.wait();
        }else{
            total--;
            System.out.println(Thread.currentThread().getName() + "消费了一个,库存"+total+"个");
            this.notify();

        }
    }
}

八：定时任务

通过Timer和Timetask，我们可以实现定时启动某个线程。
java.util.Timer
在这种实现方式中，Timer类作用是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其它线程的。
java.util.TimerTask
TimerTask类是一个抽象类，该类实现了Runnable接口，所以该类具备多线程的能力。
在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。

package 多线程;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) {
        Timer t1 = new Timer();//定义计时器；
        Task task1 = new Task();//定义任务；
        t1.schedule(task1,3000,3000);

    }
}
class Task extends TimerTask{

    @Override
    public void run() {
        System.out.println(new Date());
    }
}

九：volatile关键字

背景引出：

大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。
也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个简单的例子，比如下面的这段代码：

i=1;
i = i + 1;

当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。

　　这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题了。在多核CPU中，每条线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，其实也会出现这种问题，只不过是以线程调度的形式来分别执行的）。本文我们以多核CPU为例。
比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？
　　可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。
　　最终结果i的值是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。
　　也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。
　　为了解决缓存不一致性问题，通常来说有以下2种解决方法：
　　1）通过在总线加LOCK#锁的方式
　　2）通过缓存一致性协议
　　这2种方式都是硬件层面上提供的方式。
　　在早期的CPU当中，是通过在总线上加LOCK#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK#锁的话，也就是说阻塞了其他CPU对其他部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。比如上面例子中 如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了LCOK#锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。
　　但是上面的方式会有一个问题，由于在锁住总线期间，其他CPU无法访问内存，导致效率低下。
　　所以就出现了缓存一致性协议。最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

并发编程的三个概念：

1.原子性

　　原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
　　一个很经典的例子就是银行账户转账问题：
　　比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。
　　试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。
　　所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。
　　同样地反映到并发编程中会出现什么结果呢？
　　举个最简单的例子，大家想一下假如为一个32位的变量赋值过程不具备原子性的话，会发生什么后果？

i = 9;

　　假若一个线程执行到这个语句时，我暂且假设为一个32位的变量赋值包括两个过程：为低16位赋值，为高16位赋值。
　　那么就可能发生一种情况：当将低16位数值写入之后，突然被中断，而此时又有一个线程去读取i的值，那么读取到的就是错误的数据。

2.可见性

　　可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
　　举个简单的例子，看下面这段代码：

//线程1执行的代码
int i = 0;
i = 10;
//线程2执行的代码
j = i;

假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

　　此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.
　　这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

3.有序性：

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2
 
//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

　　上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。
　　从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。
　　也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

4.java内存模型：

Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。
1.原子性
　　在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。
　　上面一句话虽然看起来简单，但是理解起来并不是那么容易。看下面一个例子i：
　　请分析以下哪些操作是原子性操作：

x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4

　 咋一看，有些朋友可能会说上面的4个语句中的操作都是原子性操作。其实只有语句1是原子性操作，其他三个语句都不是原子性操作。
　　语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。
　　语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及 将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。
　　同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。
　　所以上面4个语句只有语句1的操作具备原子性。
　　也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。
　　不过这里有一点需要注意：在32位平台下，对64位数据的读取和赋值是需要通过两个操作来完成的，不能保证其原子性。但是好像在最新的JDK中，JVM已经保证对64位数据的读取和赋值也是原子性操作了。
　　从上面可以看出，Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。
2.可见性
　　对于可见性，Java提供了volatile关键字来保证可见性。
　　当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
　　而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
　　另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
3.有序性
　　在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
　　在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。
下面就来具体介绍下happens-before原则（先行发生原则）：
程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作
锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C
线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始
　　这8条原则摘自《深入理解Java虚拟机》。
　　这8条规则中，前4条规则是比较重要的，后4条规则都是显而易见的。
{{uploading-image-335170.png(uploading...)}}


上面三张图意在说明，volatile只能保证可见性与有序性，不能保证原子性。缓存无效只在读数据的时候，A线程读到100后，有一定的延迟（还未写回），此时B线程也将100读入，并且-1后迅速写回内存，此时A线程的-1已经执行完了，缓存无效跟它无关。
Volatile的其他作用
可举单例模式的实现，典型的双重检查锁定（DCL）：

class Singleton{
    private volatile static Singleton instance = null;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if(instance==null) { // 1
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton(); // 2
            }
        }
        return instance;
    }
}

这是一种懒汉的单例模式，使用时才创建对象，而且为了避免初始化操作的指令重排序，给instance加上了volatile。
为什么用了synchronized还要用volatile？具体来说就是synchronized虽然保证了原子性，但却没有保证指令重排序的正确性，会出现A线程执行初始化，但可能因为构造函数里面的操作太多了，所以A线程的instance实例还没有造出来，但已经被赋值了（即代码中2操作，先分配内存空间后构建对象）。
而B线程这时过来了（代码1操作，发现instance不为null），错以为instance已经被实例化出来，一用才发现instance尚未被初始化。要知道我们的线程虽然可以保证原子性，但程序可能是在多核CPU上执行。

十：ThreadLocal