多线程编程

一: 两种实现方式:

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

posted @ 2020-02-16 15:59  彩笔梳子0806  阅读(...)  评论(...编辑  收藏