Java学习日记——多线程&JUC

线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

（进程：进程是程序的基本执行实体）

软件中可以同时进行，相互独立的功能

并发&并行：

并发:在同一时刻，有多个指令在单个CPU上交替执行

并行:在同一时刻，有多个指令在多个CPU上同时执行

多线程的实现方式：

继承Thread类的方式进行实现：

class Mythread extends Thread{
//重写run方法
    pubilc void run(){  sout(getName())};//有继承关系可以直接用父类的方法
}

Mythread t1=new Mythread();
Mythread t2=new Mythread();
t1.setName("t1");
t2.setName("t2");

t2.start()；//t2 t1交织运行但不一定是1:1
t1.start();

实现Runnable接口的方式进行实现：

自己定义一个类实现runnable接口，重写run方法，创建对象，创建一个thread类的对象，实现多线程

class Mythread implements Runnable{
//重写run方法
    @override
    pubilc void run(){  
    Thread t=Thread.currentThread();//返回当前线程的对象
    sout(t.getName());  };//这里是没有继承关系，所以不能直接用
    //或者直接Thread.currentThread().getName()
}

Mythread mt=new Mythread();
Thread t1=new Thread(mt);//t2同理
//设置名字
t1.start();
t2.start();

利用Callable接口和Future接口方式实现：

特点：能获取多线程返回的结果

1．创建一个类MyCallable实现Callable接口

2．重写call（是有返回值的,表示多线程运行的结果)

3.创建MyCallable的对象（表示多线程要执行的任务)

4．创建FutureTask的对象（作用管理多线程运行的结果)

5.创建Thread类的对象，并启动（表示线程)

class Mythread implements Callable<Integer>{ //Interger表示返回值结果
    @override
    public Integer call() throws Exception{
        int sum;
        //sum从1加到100
        return sum;
    }
}
Mythread mt=new Mythread();
FutureTask<Integer> ft=new FutureTask<>(mt);
Thread t1=new Thread(ft);
t1.start();
Integer result=ft.get();//获得多线程的结果

常见成员方法：

//如果没有设置名字，线程也有默认的名字：Thread-X（X为序号，从0开始）
//在Thread构造方法也可以传入名字,但是要在自己的类中调用，创建的时候是创建自定义类,该种构造方法是父类Thread的
public MyThread(String name){ super(name); }

//currentThread() 哪条线程执行到这个方法获取的就是哪个线程的对象
main中：
Thread t=Thread.currentThread();
t.getName()=="main"

//sleep 哪条线程执行到这个方法，哪条线程停对应的时间；时间到后自动执行

优先级：

抢占式调度；但是随机

setPriority最小1，最大10，默认5 （代表概率）

守护线程：

当其他非守护线程执行完毕的时候，守护线程就陆续结束（就是不一定会执行完毕，没存在的必要了）

t2.setDeamon(true);//设置为守护线程
t1.start();t2.start();

出让线程&插入线程：

使用在重写的run方法中：

//出让:
run{
    Thread.yield();//尽可能均匀，但不一定
}
//插入：
main{
    //t插入到当前线程之前，当前线程看在哪里执行的，这里是main
    t.join();
}

线程的生命周期：

多线程的安全问题：

多线程共用一个数据的时候，需要使用static静态关键字表示，但是这样也会出现数据溢出范围的情况或者是跳过数据的情况，因为线程执行过程中有随机性，随时都可能被抢走。

锁对象是任意的，但一定要是唯一的，随便在上面创建一个object都行（static Object），一般用当前类的字节码对象，类名.class

选中所有代码，ctrl+alt+m

Lock锁：

MyThread(){
 static Lock lock=new ReentrantLock();//共用一把锁
    run(){
    lock.lock();
    //代码块
    lock.unlock();//记得关锁，不然不知道什么时候暂停
}//关锁的操作可以放在try的final中
}

死锁：

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

死锁面试题（什么是死锁，产生死锁的原因及必要条件）_AddoilDan的博客-CSDN博客_死锁

等待唤醒机制：

思想：生产者制作，放到桌子上，叫消费者使用，消费者使用后等待生产者，生产者制作完成后唤醒消费者

public class Cook extends Thread{
    run{
    while(true){
        synchronized(Desk.lock){
            if(Desk.count==0) break;
            else{
                 if(Desk.foodflag==1) Desk.lock.wait();
                 else { 行为;Desk.foodflag=1;Desk.lock.notifyAll();}       
        } }
    }
    }
}
public class Foodie extends Thread{
    run{
    while(true){
        synchronized(Desk.lock){
            if(Desk.count==0) break;
            else{
                 if(Desk.foodflag==0) Desk.lock.wait();//当前线程和锁绑定，后面唤醒才知道是唤醒什么
                 else { 行为;Desk.foodflag=0;Desk.lock.notifyAll();Desk.count--;}       
        } }
    }
    }
}
}
public class Desk extends Thread{//控制生产者和消费者的行为
    public static int foodflag=0;//0没有，1有
    public static int count=10;//总次数
    public static Object lock=new Object();//锁对象
    run{}
}

利用阻塞队列方式实现：

生产者消费者必须使用同一个阻塞队列

//测试类
ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(1);//1是队列的容量
Cook c=new Cook(queue);
Foodie f=new Foodie(queue);
c.start();f.start();
//以上可以实现厨师放，消费者拿，虽然实际输出不是轮次，是因为输出语句在锁的外面，

线程的状态：

线程池：

不需要每次用完都丢掉线程，可以重复利用

1，创建线程池 2，提交任务 3，所有的任务全部执行完毕，关闭线程池（一般不用关闭）

（没有上限的上限是int）

ExecutorService pool1=Executors.newCachedThreadPool();
pool1.submit(new MyRunnalbe());//提交任务， MyRunable是现实了Runnable类的对象
pool1.shutdown();//销毁

线程池主要核心原理:1.创建一个池子，池子中是空的

2.提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子.下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可

3.但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待

自定义线程池:

ThreadPoolExecutor pool=new ThreadPoolExecutor(3,6,1,TimeUnit.SECONDS,
new ArrayBlockingQueue<>(3),Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()//拒绝策略是静态内部类
);