【多线程】

进程： 当运行了一个程序，开始了一个进程。window操作系统是多进程的操作系统，操作系统能够同时运行多个 进程。其实是由CPU交替执行这些进程，间隔时间非常短，认为这些进程是同时执行的。

线程：一个进程中执行的多个顺序流（任务），多线程的实现是通过创建Thread类的对象。

创建线程的第一种方式：创建Thread类的对象

需求：模拟一个火车站窗口买票的程序，有三个窗口同时卖票，每个窗口要卖1000张票，用编程模拟

//多线程类，本身的功能：JVM允许MyThread对象 并发运行
public class MyThread extends Thread{
    //通过重写run方法，将运行的代码写在run中
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for(int i = 1;i<=1000;i++) {
            System.out.println("窗口"+this.getName()+"买了"+i+"张票");
        }    
    }
}

public class TestThread {
    public static void main(String[] args) {
    /* for(int i = 1;i<=1000;i++) {
        System.out.println("窗口A买了"+i+"张票");
    }
    for(int i = 1;i<=1000;i++) {
        System.out.println("窗口B买了"+i+"张票");
    }
    for(int i = 1;i<=1000;i++) {
        System.out.println("窗口C买了"+i+"张票");
    }*/
    //创建三个线程
    MyThread t1 = new MyThread("A");
    MyThread t2 = new MyThread("B");
    MyThread t3 = new MyThread("C");
    //调用线程对象的start方法，启动多线程，JVM自动调用run方法并实现并发功能
    t1.start();
    t2.start();
    t3.start();
    }
}

Thread类的start方法： 使线程进入到可运行状态（runnable状态），CPU只能调用runnable状态的多线程

上面的程序在运行时，其实启动了四个多线程，分别是三个MyThread和一个主线程(Main方法的线程)

创建线程的第二种方式：采用实现Runnable接口的方式

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 1;i<=1000;i++) {
            //Thread.currentThread() 获得执行这段代码当前的线程对象
            System.out.println("窗口"+Thread.currentThread().getName()+"买了"+i+"张票");
        }
    }
}

//创建三个线程
//描述了线程要执行的任务（顺序流）
MyRunnable mr = new MyRunnable();
//t1线程要执行什么任务
Thread t1 = new Thread(mr,"A");
Thread t2 = new Thread(mr,"B");
Thread t3 = new Thread(mr,"C");
t1.start(); //mr对象.run()
t2.start(); //mr对象.run()
t3.start(); //mr对象.run()
System.out.println(Thread.currentThread().getName());

优点：

1. 实现了Runnable接口的类还可以继承其他的类

2. 可以多个线程操作同一个对象

线程的生命周期状态

线程对象从创建到销毁，有一些状态的改变的，通过调用线程的API方法实现这些状态的改变

Thread类常用的方法

1. sleep方法：静态方法，Thread.sleep(毫秒值) 让当前的线程等待，直到指定的毫秒值后唤醒

while(true) {
    System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()));
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
}

2. join方法：等待该线程终止 ，当在一个线程中调用另一个线程的join方法，当前的线程将阻塞，直到另一个线程执行完毕后，当前线程解除阻塞

public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();
    //t1线程要执行什么任务
    Thread t1 = new Thread(mr,"A");
    Thread t2 = new Thread(mr,"B");
    Thread t3 = new Thread(mr,"C");
    t1.start(); //mr1对象.run()
    t2.start(); //mr1对象.run()
    t3.start(); //mr1对象.run()
    //主线程要阻塞 ，等t1t2t3
    try {
        t1.join();
        t2.join();
        t3.join();
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
    System.out.println("=====火车开了=====================");
}

3. yield方法：暂停当前的调度，将线程从running状态变为runnable状态

4. currentThread() :静态方法，获得当前的线程对象

5. getName() ： 获得线程对象的名字

6. getId() : 获得线程的id

7. isAlive() : 是否是可运行状态

8. setDaemon() : 设置线程为守护线程，守护线程的特点是，守护其他所有的线程，其他线程结束后，守护线程 会自动结束。

9. setPriority() /getPriority() :设置/获取线程的优先级

线程同步

同步和异步：

异步：两个任务同时进行的工作是异步；

同步：同是协同的意思，两个线程在使用同一个资源时，一 个线程再占用这个资源时，另一个线程将等待。

例如：实现一个投票程序，多个线程可以进行投票，采取异步的方式 ；实现一个存取款的程序，多个线程可以同时存取款，要采用同步的方式。