2019-08-18 Day17创建多线程

目的

了解多线程的概念 初步掌握多线程的使用方法

多线程

要了解多线程，首先要了解两个概念 进程和线程
进程：
正在运行的一个程序
系统会为这个进程分配独立的内存空间
线程：
具体执行任务的最小单位
一个进程最少拥有一个线程（主线程 运行起来就执行的线程）
线程之间是共享内存资源的
线程之间可以通信（通常在主线程和子线程之间）
每一个线程都有自己的运行回路（生命周期）

所以说，线程是操作系统运行的基本单位，它被封装在进程中，一个进程可以包含多个线程。

为什么要使用多线程

如果在主线程中存在有比较耗时的操作，下载视频上传文件，这些操作会阻塞主线程，后面的任务必须等这些任务执行完毕，之后才能执行，用户体验比较差，为了不阻塞主线程，需要将耗时的任务放在子线程中去处理，也就形成了多线程

线程的生命周期

NEW 新建 线程刚刚被创造好
RUNNABLE： 就绪状态
BLOCKED 阻塞状态
WAITING 等待
TERMINATED 终止

如图：

线程状态.png

创建线程和启动

（1）继承Thread类创建线程类，步骤如下
1.定义一个继承Thread类的子类，并重写该类的run()方法；
2.创建Thread子类的实例，即创建了线程对象；
3.调用该线程对象的start()方法启动线程。

public class MyClass {
    public static void main(String[] args){
        //main方法里面执行的代码 是在主线程里面执行的
        //创建thread对象
 TestThread tt = new TestThread();
        //设置线程的名称
        tt.setName("子线程1");
        //开启任务
        tt.start();

        TestThread tt2 = new TestThread();
        //设置线程的名称
        tt2.setName("子线程2");
        //开启任务
        tt2.start();}
}
class TestThread extends Thread{
    //实现run方法
    //方法里面就是具体需要执行的代码

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 100; i++) {

            System.out.println("name:"+name+" "+(i+1));

        }
        super.run();
    }
}

(2.)实现Runnable接口创建线程类,步骤如下
1.定义Runnable接口的实现类，并重写该接口的run()方法；
2.创建Runnable实现类的实例，并以此实例作为Thread的target对象，即该Thread对象才是真正的线程对象。

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

PXDThread pt = new PXDThread();

      //使用Thread操作这个任务
      Thread t = new Thread(pt);
      t.setName("子线程1");
      t.start();

      Thread t2 = new Thread(pt);
        t2.setName("子线程2");
        t2.start();
}
}
class PXDThread implements   Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+(i+1));
        }

    }
}

线程安全

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。比如说在买票系统中，如果没有采用加锁机制，就会导致，一张票被两个人所购买的情况。

如何实现线程安全

实现线程安全，主要通过，synchronized 或者LOCK 进行加锁解锁，主要有两种方法
1.同步代码块
2.同步方法

public class MyClass {
    public static void main(String[] args){
 Ticket ticketCQ = new Ticket("重庆");
     Thread t1 = new Thread(ticketCQ);
     t1.start();

        Ticket ticketSH = new Ticket("上海");
        Thread t2 = new Thread(ticketSH);
        t2.start();
    }
}//用于卖票的任务
class Ticket implements Runnable{
    public static  int num = 100;
    String name;

    public Ticket(String name){
        this.name = name;


    }
    static  final Object obj = new Object();
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //判断有没有票
            synchronized (obj) {
                    //需要同步的代码

                if (num > 0) {

                    System.out.println(name + "出票：" + (101 - num));
                    num--;
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        //通知其他线程执行
                        notify();
                    }
                } else {
                    break;
                }
            }
        }

这里我们用synchronized同步代码块的方法 进行了加锁解锁，但实际上同步方法，本质上也是利用了同步代码块，只是同步的监听器是当前对象本身，容易出错，所以必须确保多个对象调用的同步方法是操作的同一个对象。