[Java知识库]Java线程（基础）

线程介绍

进程

线程

单、多线程

1.单线程:同一个时刻，只允许执行一个线程
2.多线程:同一个时刻，可以执行多个线程，比如:一个qq进程,可以同时打开多个聊天窗口,一个迅雷进程，可以同时下载多个文件

并发和并行

线程的使用

创建线程的两种方法

在java中线程来使用有两种方法。
1.继承Thread类,重写run方法
2.实现Runnable接口，重写run方法

机制说明

当main线程通过start()方法启动一个子线程Thread-0，并不代表主线程会阻塞，它会继续执行，并且与子线程交替执行
主线程结束但是任有子线程不会造成应用程序的结束
主线程可以开多个子线程，子线程也能开新的子线程

举例说明（继承Thread类重写run（）方法实现线程）

创建一个进程每隔一秒输出内容，输出8次后停止

package Threaduse;
//演示通过继承Thread 类创建线程
public class Test {
    public static void main(String[] args) {
        //创建Cat对象，可以当做线程使用
        cat cat = new cat();
        cat.start();//启动线程-> 最终会执行cat的run方法
    }
}
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class cat extends Thread{
    //重写run（）方法

    @Override
    public void run() {//在这里写上自己要实现的业务逻辑
        super.run();
        int times=0;
        while(true){
            System.out.println("熊猫烧香"+times++);
            //休眠一秒钟(一毫秒为单位)，抛出异常ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times==8){
                break;
            }
        }
    }
}

为什么调用start（）不直接调用run（）方法？

cat.run()//是一个普通方法，由主线程直接调用run（）方法，无法实现线程
cat.start()//启动线程，最终会执行cat.run()方法


start（）方法源码解读：
run（）方法何时执行取决于CPU

举例（实现Runnable接口实现线程）

说明

1. java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
2. java设计者们提供了另外一个方式创建线程,就是通过实现Runnable接口来创建线程

深入内容到之后再讲，先介绍怎么实现

package Threaduse;

public class Thread02 {
    public static void main(String[] args) {
        //底层使用了代理模式（一种设计模式）
        Dog dog = new Dog();
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable {

    @Override
    public void run() {
        //设置自己想设计的逻辑
        int num=0;
        while(true){
            System.out.println("熊猫烧香"+(++num)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num==8){
                break;
            }
        }
    }
}

继承Thread和Runnable接口对比

售票系统（出现了超票问题，该怎么解决）

package Threaduse;

public class SellTicketSystem {
    public static void main(String[] args) {
        //使用Thread实现线程
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        //使用Runnable接口
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread thread = new Thread(sellTicket02);
        Thread thread2 = new Thread(sellTicket02);
        Thread thread3 = new Thread(sellTicket02);
        thread.start();
        thread2.start();
        thread3.start();
    }
}
class SellTicket01 extends Thread {
    private static int nums=100;
    @Override
    public void run() {
        while(true){
            if(nums<=0){
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("售票口"+Thread.currentThread().getName()+"卖出一张票"+"剩余票数"+(nums--));
        }
    }
}
class SellTicket02 implements Runnable {
private int nums=100;//这里不用定义static，因为始终使用的是同一个SellTicket02生成的对象
    @Override
    public void run() {
        while(true){
            if(nums<=0){
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("售票口"+Thread.currentThread().getName()+"卖出一张票"+"剩余票数"+(nums--));
        }
    }
}