【JavaSE】线程，同步与死锁，Thread类 ,Runnable接口 ,synchronized ()，wait(),经典案例：生产者与消费者

一、Java中多线程的创建和使用

Thread类

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread类的特性：
      每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
      通过该Thread对象的**start()**方法来调用这个线程，启动线程

Thread类构造方法：

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

继承Thread类创建线程

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

public class TestThread extends Thread{
   
    /**
     * 继承Thread的方式实现多线程
     * @author lby
     *
     */

    @Override
    public void run() {
   
        System.out.println("多线程运行的代码");
        for(int i = 0; i < 5; i++){
   

            System.out.println("这是多线程的逻辑代码:" + i);
        }
    }
}

实现Runnable接口（一般用这个）

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

public class TestRunnable implements Runnable {
   
    @Override
    /**
     * 通过实现Runnable接口方式实现多线程
     * @author lby
     *
     */

    public void run() {
   
        int count = 0;
        //Thread.currentThread().getName()获取线程名称
            System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
            for (int i = 0; i < 5; i++) {
   
                count++;
                System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
            }

    }
}

public class text {
   
    public static void main(String[] args) {
   
 //       Thread t0 = new TestThread();//继承Thread类的线程
//		t0.start();//启动线程,开始运行run方法中的代码


        Thread t1 = new Thread(new TestRunnable());//传入一个Runnable的实例
        //t1.start();

        Thread t2 = new Thread(new TestRunnable() , "t-1");
        t2.start();
        Thread t3 = new Thread(new TestRunnable() , "t-2");
        t3.start();


        System.out.println("---------------");
        System.out.println("---------------");
        System.out.println("---------------");
    }
}

继承方式和实现方式的联系与区别

【区别】
继承Thread: 线程代码存放Thread子类run方法中。重写run方法
实现Runnable：线程代码存在接口的子类的run方法。实现run方法

【实现接口方式的好处】
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
一般使用实现接口方式来实现多线程

共享同一个接口实现类：

Runnable run =  new TestRunnable();
        Thread t4 = new Thread(run , "t-1");
        t4.start();
        Thread t5 = new Thread(run , "t-2");
        t5.start();

int count = 0;
    public void run() {
   
        //Thread.currentThread().getName()获取线程名称
            System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
            for (int i = 0; i < 5; i++) {
   
                count++;
                System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
            }

    }

输出结果：

t-2:Runnable多线程运行的代码
t-1:Runnable多线程运行的代码
t-1:这是Runnable多线程的逻辑代码:2
t-1:这是Runnable多线程的逻辑代码:3
t-1:这是Runnable多线程的逻辑代码:4
t-1:这是Runnable多线程的逻辑代码:5
t-1:这是Runnable多线程的逻辑代码:6
t-2:这是Runnable多线程的逻辑代码:1
t-2:这是Runnable多线程的逻辑代码:7
t-2:这是Runnable多线程的逻辑代码:8
t-2:这是Runnable多线程的逻辑代码:9
t-2:这是Runnable多线程的逻辑代码:10
共享了TestRunnable里的count

二、Thread的相关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name): 设置该线程名称
static currentThread(): 返回当前线程

线程的优先级控制
MAX_PRIORITY（10）; 最高优先级（10）
MIN _PRIORITY （1）; 最低优先级（1）
NORM_PRIORITY （5）;默认优先级（5）
涉及的方法：
getPriority() ： 返回线程优先值
setPriority(int newPriority) ： 改变线程的优先级
线程创建时继承父线程的优先级

static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()： 返回boolean，判断线程是否还活着

public class text1 {
   
    public static void main(String[] args) {
   

        Textrun run0 = new Textrun();
        Textrun run1 = new Textrun();

        Thread t0 = new Thread(run0);
        t0.start();
        Thread t1 = new Thread(run1);
        t1.start();

        //t0.setName("线程01");//设置名称

        //t0.setPriority(1);//设置线程的优先级
		//t1.setPriority(10);//设置线程的优先级

        //创建线程时不指定名称会输出默认名称
        // System.out.println(t0.getName());
        // System.out.println(t1.getName());

        /**
         * 线程的优先级，就是哪个线程有较大个概率被执行
         * 优先级是用数组1-10表示，数字越大优先级越高，如果没有设置默认优先级是5
         */

		// System.out.println("t0的优先级：" + t0.getPriority());//获取线程的优先级
		// System.out.println("t1的优先级：" + t1.getPriority());//获取线程的优先级

        System.out.println("---------------");
        System.out.println("---------------");
        System.out.println(t1.isAlive());//判断当前的线程是否存活

        t1.stop();//强制线程生命期结束,强制停止此线程

        try {
   
            t0.join();//相当于在这块把t0的run的代码插入到这个位置执行
            /**
             * 专业的说法
             * 就是阻塞当前的main方法，先不执行System.out.println("---------------3");代码
             * 先执行join进来的线程的代码
             * join的线程执行完毕之后继续执行之前main方法阻塞的代码System.out.println("---------------3");
             */
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }

        System.out.println("---------------");
        System.out.println(t1.isAlive());
    }
}


class Textrun implements Runnable{
   

    int count = 0;
    @Override
    public void run() {
   
        //Thread.currentThread().getName()获取线程名称
        System.out.println(Thread.currentThread().getName(