JavaEE进阶知识学习----多线程JUC知识学习

多线程基础知识

1.概述程序，进程和线程

程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。
进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。
线程：是进程的小单元，是一个程序内部的一条执行路径。

多线程的创建和使用

创建方法一

继承Thread类，重写Run()方法

使用说明：

• 定义子类继承Thread类。
• 子类中重写Thread类中的run方法。
• 创建Thread子类对象，即创建了线程对象
• 调用线程对象的start方法，启动线程，调用run方法。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
   
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.start();
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

Thread类常用方法说明

• start(),启动线程并执行相应的run()方法。
• run(),子线程要执行的代码放在run()方法中。
• currentThread(),静态方法，调取当前的线程。
• getName(),获取此线程的名字。
• setName(),设置此线程的名字。
• yield(),调用此方法的线程释放当前cpu的执行权。

以上方法的测试代码如下：

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
   
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i % 10 == 0){
                Thread.currentThread().yield();
            }

        }
    }
}

• join(),在A线程中调用B线程的join()方法，表示A线程执行到此方法，A线程停止执行，直到B线程执行结束，在执行A线程剩余的。
• isAlive(),判断线程是否还存活。
• sleep(long long),显示的让当前线程睡眠long毫秒。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }   
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
   
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i == 20){
                try {
                    st.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(st.isAlive());
    }
}

• 线程通信：wait(),notify(),notifyAll()
• getPriority()，返回线程的优先值。
• setPriority(int newPriority),改变线程的优先级。

继承方式实例

模拟火车站售票窗口，开启三个窗口售票，总票数为100张

class Window extends Thread{
    static int ticket = 100;

    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class ThreadDemo {
   
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

注意：ticket只有声明为static,因为三个线程是三个对象，如果不声明为static，三个线程对象就会各自拥有一个ticket=100，使用static修饰后，三个对象共用一个ticket=100。

创建方法二

实现Runnable接口

• 定义子类，实现Runnable接口。
• 子类重写Runnable接口中的run方法。
• 通过Thread类含参构造器创建线程对象。
• 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
• 调用Thread类的start方法，开启线程并调用Runnable子类的run方法。

class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for(int i = 1 ; i <= 100; i++){
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class TestRunnable {
   
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        t1.start();
        Thread t2 = new Thread(ra);
        t2.start();
    }
}

实现方式实例

class RunnableDemo implements Runnable{
    int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class TestRunnable {
   
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

继承和实现

联系和区别

区别：
继承：线程代码存放在Thread子类的run方法中。
实现：线程代码存放在接口的子类的run方法中。
实现的好处：

• 避免了单继承的局限性
• 多个线程可以共享同一个接口的实现类的对象，适合多个线程来处理同一份资源。

线程的调度

调度策略

时间片：就是按时间顺序，先到先执行。
抢占式：高高优先级的线程抢占CPU。

调度方法

1.同优先级线程组成先进先出队列，使用时间片策略。
2.对高优先级，使用优先调度的抢占式策略。

线程的优先级

MAX_PRIORITY（10）; 最大的优先级
MIN _PRIORITY （1）; 最小的优先级
NORM_PRIORITY （5）; 默认的优先级
getPriority()，返回线程的优先值。
setPriority(int newPriority),改变线程的优先级。
线程的创建时继承父线程的优先级。
优先级别只是说线程抢占CPU的概率增加，并不能说是一定高优先级的先执行完。

线程的生命周期

JDK中用Thread.State枚举表示线程的几种状态。

• 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
• 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
• 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
• 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
• 死亡：线程完成了它的全部工作或线程被提前强制性地中止

线程的同步机制

在上面使用继承和实现方法的案例中，有时运行会出现一种情况重票，和负票的情况。这个就是线程安全问题。

线程安全问题原因

我们创建了多个线程，存在共享数据，那就有可能出现线程安全问题，当其中一个线程操作共享数据时，还未操作完成 ，另外的线程参与进来，导致对共享数据的操作出现问题。

解决方法

要求一个线程操作共享数据结束后，其他线程才能参与进来。

方式一：同步代码块

synchronized(同步监视器){
    //需要被同步的代码块（即为操作共享数据的代码）
}

共享数据：多个线程共同操作的同一数据（变量）。
同步监视器：由一个类的对象来充当，那个线程获取此监视器，谁就执行大括号里面被同步的代码。俗称锁，任何一个类的对象都可以充当锁，要想保证线程的安全，就必须要求所有的线程共用一把锁。（如果将锁放在run方法里，就成了局部变量，就不会保证线程安全）
使用实现的方式中，同步监视器可以使用this，继承的的方式慎用this。

class RunnableDemo implements Runnable{
    int ticket = 100;//共享数据
    @Override
    public void run() {
        while(true){
            synchronized(this){
                if(ticket > 0<