多线程编程

无论PC还是智能手机现在都支持多任务，都能编写并发访问程序。多线程编程可以编写并发访问程序。

基础知识

那么线程究竟是什么？在windows操作系统出现之前，pc上的操作系统都是单任务系统，只有在大型计算机上才具有多任务和分时设计。随着windows、Linux等操作系统出现，把原本只在大型计算机才具有的特点带到了pc系统中。

进程

一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中，每一个进程的内部数据和状态都是独立的。
在windows操作系统中可以通过Ctrl+Alt+Del键，然后选择任务管理器对我们的进程进行查看。

线程

线程与进程相似，是完成某个特定功能的代码，是程序中单个顺序控制的流程，但与进程不同的是，同类的多个线程是共享一个块内存空间和一组系统系统资源。所以在系统中各个线程切换时，开销要比进程小的多。所以线程被称为轻量级进程。一个进程可以包含多个线程。

主线程

Java程序至少会出现一个线程，就是主线程，程序启动后是由JVM创建主线程，程序结束时有JVM停止主线程。主线程它负责管理子线程，即子线程的启动，挂起，停止等操作。
获取当前主线程名字

package dfc;

public class MyThread {

    public static void main(String[] args) {
        //获取当前线程
        Thread thread = Thread.currentThread();
        //打印处当前线程的名字
        System.out.println(thread.getName());
    }
}

通过getName()得到主线程的名字，主线程名字时main,有JVM分配。

创建子线程

• 实现Runnable接口

package dfc;

public class MyRunnable implements Runnable{
    //线程体
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("第"+i+"次执行"+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        //调用构造方法
        new Thread(myRunnable).start();
    }
}

在创建Thread对象时，可以将线程执行对象传递给它，这需要使用Thread类的两个构造方法：

• Thread(Runnable target,String name):target时线程执行对象，实现Runnable接口，name是为线程指定过一个名字。

• Thread(Runnable target) target是线程执行对象，实现Runnable接口，线程名字有JVM分配。

• 继承Thread类
  本质上Thread类也是实现了Runnable接口，所以Thread类也可以作为线程执行对象，这需要继承Thread类，覆盖run()方法。

package dfc;

public class TestThread extends Thread{

    public TestThread(){
        super();
    }
    public TestThread(String name){
        super(name);
    }
    //覆盖run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        TestThread testThread = new TestThread("子线程");
        System.out.println(testThread.getName());
        testThread.start();
    }
}

代码中定义了两个构造方法，可以通过调用父类的构造方法：
Thread(String name) name为线程指定一个名字，
Thread() 线程名字有JVM分配。

使用匿名内部类和lambda表达式实现线程体

如果线程体使用的地方不是很多，可以不用单独定义一个类，可以使用匿名内部类或者Lambda表达式直接实现Runnable接口，当Runnable中只有一个方法是函数式接口，可以使用Lambda表达式。

package dfc;

public class NiRunnable {

    public static void main(String[] args) {
        //通过匿名内部类实现Runnable接口
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
        });
        t1.start();
        
        //使用Lambda表达式实现Runnable接口
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
            }
        });
        t2.start();
    }
}

关于Lambda表达式
匿名内部类和Lambda表达式不需要定义一个线程类文件，使用起来比较方便，特别是Lambda表达式使代码变得非常简洁，但是客观上回事代码可读性变差，对于初学者不容易理解。

线程的状态

• 新建状态
  新建状态（new）是通过new等方式创建线程对象，它仅仅是一个空的线程对象。

• 就绪状态
  当主线程调用新建线程的start()方法后，它就进入就绪状态，此时的线程尚未正真开始执行run()方法，它必须等待CPU调度。

• 运行状态
  CPU的调度就绪状态的线程，线程进入运行状态，处于运行状态的线程独占CPU,执行run()方法

• 阻塞状态
  因为某种原因运行状态的线程进入不可运行状态，即阻塞状态，处于阻塞状态的线程JVM系统不能执行该线程，就算cpu空闲，也不会执行该线程，一般有以下几个原因：
  当前线程调用sleep()方法，进入休眠状态
  被其他线程调用了join方法，等待其他线程结束
  发出I/O请求，等待I/O操作完成期间
  当前线程调用了wait()方法
  处于阻塞状态的线程可以重新回到就绪状态，等待cpu重新调度使用。

• 死亡状态
  线程退出run()方法后，就会进入死亡状态，线程进入死亡状态有可以是正常实现完成run()方法进入，也可能是发生异常而进入的。

线程管理

• 线程优先级
  线程的调度程序根据线程决定每次线程应当如何运行时，java提供了10中优先级，分别有1-10表示，最高优先级为10。
  Thread类可以通过setPriority(int new Priority)方法设置线程优先级，通过getPriority()方法获得线程优先级。
• 等待线程结束
• 线程让步
• 线程停止

线程安全

在对线程环境下，访问相同资源时，会引发线程不安全问题。

• 资源临界问题
  多一个线程同时运行，有时线程之间需要资源共享数据，一个线程需要其他线程的数据，否则就不能保证程序运行结果的正确性。列如买票系统。
• 线程同步方法
  为了防止多线程对临界资源的访问有时会导致数据的不一致性，java提供了“互斥”机制，可以为这些资源对象加上一把“互斥锁”,在任意时刻只能由一个线程访问资源，即使该线程出现阻塞问题，该对象的锁定状态也不会被解除，其他线程仍不能访问该对象，这就实现了多线程同步。线程同步保证线程安全的重要手段，但是线程同步客观上会导致性能下降。
  通过两种方式实现线程同步：一种时使用synchronized()方法，使用synchronized()来修饰方法，对方法进行同步；第二种是使用synchronized关键字放在对象前面限制一段代码的执行。

package dfc;

public class synThread extends Thread{

    //机票数量
    private int tickCount = 5;
    //获得当前机票的数量
    public synchronized int getTickCount(){
        return tickCount;
    }
    //售卖机票
    public synchronized void sellTick() throws InterruptedException {
        //相当于用户付款
        //线程休眠，阻塞当前线程，模拟用户付款
        Thread.sleep(1000);
        System.out.println("第"+tickCount--+"号票已经卖出");
    }
  
}

线程间通信

• 生产者消费者问题
  一个线程生成一些数据，将数据压栈，另一个线程消费了这些数据，将数据出栈。这两个线程互相依赖，当堆栈为空时，消费线程无法取出数据，应该通知生产者线程添加数据；当堆栈已满时，生产者线程无法增加数据，应该通知消费者线程取出数据。

package dfc;

//堆栈类
public class SAndX {
    //堆栈指针初始为0
    private int pointer = 0;
    //堆栈由五个字符空间
    private char[] data = new char[5];

    //压栈方法 加上互斥锁
    public synchronized void push(char c){
        while (pointer == data.length){
            try {
                //等待，知道由数据出去
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //通知其他线程取数据
        this.notify();
        //数据压栈
        data[pointer] = c;
        //指针向上移动
        pointer++;
    }

    
    //出栈方法 加上互斥锁
    public synchronized char pop(){
        //无数据不能出栈
        while (pointer == 0){
            try {
                //等待其他线程把数据压栈
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //通知其他线程压栈
        this.notify();
        //指针线下移动
        pointer--;
        //数据出栈
        return data[pointer];
    }
}