进程与线程--复习

进程与线程

HA（High Availability）高可用：指在高并发的情境中，尽可能的保证程序的可用性，减少系统不能提供服务的时间

进程的特点：
**独立性：**都有自己独立的空间，不会互相影响
**动态性：**要与程序【静态的数据与指令的集合】做区分，给程序加入了时间的概念
**并发性：**多个资源抢占CPU，要与并行【有多个CPU处理，不会抢占】相对
**高并发：**多个进程抢占公共资源

线程的特点：
线程是操作系统可以进行运算调度单的最小单位
一个进程可能包含多个线程，也可能只有一个线程【单线程程序】
**随机性：**微观时刻，同一时间，单个CPU只能干一件事，OS制定了一个概念
时间片–OS分配给当前线程被CPU处理的时间片段，如果就绪队列中的线程被OS选中，会执行。时间片用完【挂起】或阻塞【处理】

线程的状态：
**就绪：**当前线程所有资源均准备好，只要OS选中，就可立即执行
**执行：**OS在就绪队列根据调度规则【FCFS/SJS】选择线程来执行
**阻塞：**线程在执行时遇到了问题，需要加入到阻塞队列等待处理，处理完毕加入就绪队列
**创建：**申请PCB【线程控制块，是一种用来存储线程相关信息的数据结构】
**终止：**释放PCB

多线程编程的两种实现方式

1.继承的方式：extends Thread
**优点：**写法简单
**缺点：**后续无法再继承其他类
2.实现的方式：implements Runnable
**优点：**多实现，更加灵活且解耦
**缺点：**写法相对复杂，还有一些资源需要借助Thread

---

new–>对应的就是线程的新建状态
run()–>这是一个必须重写/实现的方法，本方法里放着的是业务
start()–>调用此方法，才会使线程以多线程的方式启动【会把本线程加入到就绪队列】
start()在执行时，底层会自动调用run()完成业务
问题：调用start()时，线程不会立即执行，只是加入到就绪队列，等待OS选中

多线程数据安全隐患

怎么出现：常见情况是由于线程的随机性+访问延迟
判断：在多线程程序中+有共享数据+多条语句操作共享数据
1.单线程程序不会出现多线程抢占资源的情况
2.如果没有共享数据，互不干涉，也不会出现数据的安全问题
3.多条语句操作了共享数据，而多套语句的执行是需要时间的，存在延迟
所以和格式检查导致了数据的安全问题

多线程安全问题解决方案

加锁的位置：
容易出现线程安全问题的资源
加锁：注意加锁的范围–太大，整个程序都是同步的，都得排队，效率太低，失去了多线程的效果
–太小，要保护的资源锁不住
同步与异步
同步：类似于排队的效果
好处：是线程安全的
坏处：排队效率低
异步：不排队，多线程的效果，各个线程抢占资源
好处：抢占资源效率高
坏处：可能会出现安全隐患

改造售票案例–解决售票时重卖与超卖的现象
解决方案：双重校验机制
1.增加判断控制–有票的时候再卖票，会减少超卖的概率
2.使用同步代码块–主要强调同步，也就是同一时刻统一资源只能被一个线程独享
3.sychronized(锁对象){可能会发生安全问题的代码}
TIPS:同步代码块使用的锁对象必须唯一；使用继承的方式的话，锁对象是本类的字节码对象

线程池：存放线程的池子
创建线程池的工具类：Executors.newFixedThreadPool(int自定义的线程数)
启动线程池中的线程：pool.execute(target目标业务对象);
TIPS：线程池会自动管理线程，线程池目前单机测试不关闭，需要手动关闭

锁

package cn.rua.test;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestRunnable {
    public static void main(String[] args) {
           TicketsRunnable t = new TicketsRunnable();
//        Thread a = new Thread(t);
//        Thread a1 = new Thread(t);
//        Thread a2 = new Thread(t);
//        Thread a3 = new Thread(t);
//        a.start();
//        a1.start();
//        a2.start();
//        a3.start();
        ExecutorService p = Executors.newFixedThreadPool(5);
        for (int i = 0;i<=5;i++){
            p.execute(t);
        }
    }
}
class TicketsRunnable implements Runnable{
    int tic =100;
    Object o = new Object();
    @Override
    public void run() {
    while (true){
        synchronized (o){
        if(tic>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"="+tic--);
        }
        if(tic<=0) break;
    }
    }
    }
}

package cn.rua.list;

public class TestSet {
    public static void main(String[] args) {
    TicketsThread t = new TicketsThread();
    TicketsThread t1 = new TicketsThread();
    TicketsThread t2 = new TicketsThread();
    TicketsThread t3 = new TicketsThread();
    t.start();
    t1.start();
    t2.start();
    t3.start();
    }
}
class TicketsThread extends Thread{
    static int tic =100;//静态修饰
//    Object o = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (TicketsThread.class){
                if(tic>0){
            try{
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName()+"="+tic--);
        }
            }if(tic<=0) break;
    }
    }
}