多线程一_多线程 heart-CSDN博客

本文链接：https://blog.csdn.net/heart_yang/article/details/103928568

1.进程和线程

1.进程:计算机中正在运行的程序

进程好比是工厂的车间,任一时刻,CPU总是运行一个进程,其他的进程处于非运行的状态

2.线程:是进程中的单个顺序控制流,是一条执行路径

单线程:一个进程如果只有一条执行路径,则称为单线程程序
多线程:一个程序有多条执行路径,则称为多线程程序

线程:
1.好比是车间里面的工人,一个进程可以包含多个线程
2.车间的空间是工人们共享的,一个进程的内存空间是共享的,每一个线程都可以使用这些共享的内容

在操作系统中进程和线程的设计

以多进程的形式,允许多个任务同时运行
以多线程的形式,允许单个任务分成不同的部分运行
提供协调机制,一方面防止进程之间和线程之间产生冲突,另一方面允许进程和线程之间的资源共享

2.实现多线程

方式一, 继承Thread类
步骤:

定义一个类MyThread,继承Thread类
在类中重写Thread类中的run方法
创建MyThread的对象
启动线程

Strat()和run()两者的区别:
run() :封装被线程执行的代码,直接可以调用,就相当于调用普通的方法一样
start():用于启动线程,然后JVM会自动的调用此线程的run方法

方式二:实现runnable()接口
1.步骤:

定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为Thread构造方法的参数传入进去
启动线程

2.实现runnable接口的好处

避免了java单继承的局限性
降低了耦合度

方式三:Callable和FutureTask
1.Runnable,Callable之间的区别

Runnable,是没有返回值的
Callable是有返回值的
FutureTask是Runnable的实现,

3.线程的优先级:

线程调度:

1.分时调度:

所有的线程轮流使用CPU的使用权,平均分配每个线程占用的时间

2.抢占式调度:

根据线程的优先级,优先级高的线程优先使用CPU,如果线程的优先级相同的话,会随机选择一个
在java中使用的是抢占式调度模型,多线程的执行程序是具有一定的随机性的

1. int getPriority()   返回线程的优先级
2. void setPriority(int newPriority) 改变线程的优先级,默认优先级是5,优先级的范围是1-10
3. void sleep(long millis) throws InterruptedException
    让当前正在执行的线程休眠millis毫秒,当到达时间后会自动的醒来
4. currentThread() 返回当前执行的线程对象
5. setDaemon(boolean on) 将该线程标记为守护线程

4.后台线程

在后台运行,它的任务就是为其他的线程提供服务,这种线程被称为后台线程
JVM垃圾回收就是后台线程,守护线程就是后台线程
特征:
所有的前台线程都死亡,后台线程就会自动死亡,当整个JVM中只有后台线程的时候,JVM就退出了

1. daemon  //守护线程
2. jps //查看java进程
3. jstack -l//查看进程关联的线程

设置守护线程要在开启线程之前

5.线程的生命周期

生命周期:从线程的创建到死亡

1.新建状态

通过new的方法创建线程之后,该线程是处于新建状态

2.就绪状态(就绪的线程存放在就绪的队列中)

调用start()方法开启线程,虚拟机会为其创建方法调用栈和程序计数器
此时该线程有执行资格,没有执行权

3.运行状态

当线程抢到cpu的执行权之后,就会自动的执行run()方法, 此时线程处于运行状态,拥有执行资格和执行权

当线程开始运行的时候,是不可能一直拿着CPU的执行权的,当其他的线程抢走CPU的执行权的时候,它又进入了就绪状态等待获取执行权(采用的是抢占式调度策略)

4.阻塞状态(阻塞队列存放阻塞的线程)

1.如果在线程的运行过程中调用了sleep()/join()等其他的阻塞式方法,线程就会处于阻塞状态,此时它会交出它的执行权和执行资格
2.当阻塞结束之后,线程会进入就绪队列,等待执行

5.死亡

当这个线程运行完毕/调用了stop()方法/线程抛出一个未捕获的错误的时候,线程死亡变成垃圾

6.买票案例

需求:100张票3个买票的窗口进行卖票
实现步骤
1.定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

在SellTicket类中重写run()方法实现卖票，代码步骤如下
判断票数大于0，就卖票，并告知是哪个窗口卖的
卖了票之后，总票数要减1
票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行

2.定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下

创建SellTicket类的对象
创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
启动线程

出现的问题:

相同的票出现了多次
出现了负数的票

原因:线程执行的随机性导致的

7.线程安全

多线程访问共享的资源的问题.(多窗口买票的问题)

1.解决方案

1.解决方案一
同步代码块Synchronized
尽量缩小锁的范围

2.方案二
lock锁

2.synchronized和lock之间的区别

1). 首先synchronized是java内置关键字，在jvm层面，
Lock是个java类；
2). synchronized无法判断是否获取锁的状态，
Lock可以判断是否获取到锁；trylock
3). synchronized会自动释放锁(a 线程执行完同步代码会释放锁；b 线程执行过程中发生异常会释放锁)，
Lock不会自动释放锁,需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4). 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，
而Lock锁就不一定会等待下去，如果trylock尝试获取不到锁，就会返回false,它就不会再等待了；
5). synchronized的锁可重入、不可中断、非公平，
而Lock锁可重入、可中断、可公平（两者皆可）
6). Lock锁适合大量同步的代码的同步问题，
synchronized锁适合代码少量的同步问题。

8.线程的等待唤醒机制

1.等待唤醒机制可以实现不同线程间的通信（数据交互）

多个线程共享同一把锁
锁对象.wait();//等待,会释放锁
锁对象.notify();//随机唤醒一个线程
锁对象.notifyAll()//后者是唤醒当前锁上的所有线程

 lock.lock()  //开启锁
lock.unlock()//关闭锁

线程休眠:

Thread.sleep()
TimeUnit.DAYS.sleep(3)//睡眠时间

2.sleep和wait的区别
sleep:释放资源但是不释放锁 wait:释放资源,也释放锁
sleep:时间到达后自己醒来 wait:需要通过notify/notifyAll唤醒
sleep:在任何地方都可以使用 wait只能在synchronized中使用
sleep:是Thread的方法 wait是Object的方法

9.volatile关键字

1.JMM:

JAVA内存模型,

此模型描述了java程序中各种变量(线程共享变量)的访规则,以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

所有的共享变量都存储于主内存每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。线程对变量的所有的操作(读，写)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。

2.volatile关键字

1). VolatileThread 线程从主内存读取到数据放入其对应的工作内存
2). 将flag的值更改为true，但是这个时候flag的值还没有写会主内存
3). 此时main方法读取到了flag的值为false
4). 当VolatileThread线程将flag的值写回去后，失效其他线程对此变量副本
5). 再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

volatile保证不同线程对共享变量操作的可见性，但是volatile不保证原子性

volatile与synchronized

1). volatile只能修饰实例变量和类变量，
而synchronized可以修饰方法，以及代码块。
2). Volatile保证数据的可见性,但是不保证原子性(多线程进行写操作，不保证线程安全);
synchronized修饰的同步代码块，无法被中断可以保证原子性，也可以间接的保证可见性。

原子性:
一组事物的操作要么都成功要么都失败
num–/num++ 不是线程安全的不是原子操作,会分多步执行,会分三步

1). 从主内存中读取数据到工作内存
2). 对工作内存中的数据进行++操作
3). 将工作内存中的数据写回到主内存

在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。
1.给count++添加锁,

同步锁
加lock锁

2.原子类 java.util.concurrent.atomic包

  AtomicInteger:原子型Integer，可以实现原子更新操作
    public AtomicInteger()： 初始化一个默认值为0的原子型Integer
    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    int get(): 获取值
    int getAndIncrement(): 以原子方式将当前值加1，注意，这里返回的是自增前的值。
    int incrementAndGet(): 以原子方式将当前值加1，注意，这里返回的是自增后的值。
    int addAndGet(int data): 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
    int getAndSet(int value): 以原子方式设置为newValue的值，并返回旧值