Java中的多线程（Thread）

技术：

多线程（Thread）

实际操作：

学习多线程之前，我们先要了解几个关于多线程有关的概念。

进程：正在运行的的一个程序（QQ 音乐软件浏览器之类的），系统会为这个进程分配独立的内存资源，不会具体执行任务，任务由线程来执行

29.PNG
线程：具体执行任务的最小单位
一个进程最少拥有一个线程（主线程）运行起来就执行的线程
线程之间是共享内存资源的（进程申请的内存资源）
线程之间可以通信（数据传递：多数为主线程和子线程）
每一个线程都有自己的运行回路（生命周期）
线程的生命周期（状态）：
```
  NEW：新建  线程刚被建好
```

  RUNNABLE：就绪状态 只要抢到时间片就可以运行这个线程

```
  BLOCKED：阻塞状态  sleep
```
```
  WAITING：等待状态   wait
```

  TIMED_WAITING:一个线程在一个特定的等待时间内等待另一个线程完成一个动作会在这个状态

  TERMINATED：中止状态，线程运行结束

30.PNG

像我这个迅雷软件正在运行，它就相当于一个进程。而它正在下载东西，这个下载就相当于线程。一个进程一般是有多个线程的。
线程的运行状态转换是怎么样的呢：

37.PNG

什么是多线程呢？

就是一个程序中有多个线程正在执行。
那么我们如何来创建一个线程呢？注意了，没有创建进程的说法，进程就是一个程序在运行。

我们为什么要来创建子线程呢？

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

我们有三种方式来创建一个线程。

1.写一个类继承于Thread 实现run方法

join:让当前这个线程阻塞等join的线程执行完毕在执行
setName:设置线程名称
getName:获取线程名称
currentThread：获取当前运行的线程对象
start:开启任务

class TestThread extends Thread{
    //实现run方法
    //方法里面就是具体需要执行的代码

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

ublic class MyClass {
    static TestThread tt2;
    public static void main(String[] args) {//main方法里面的代码，实在主线程里面执行的
        //主线程的名称为main，主线程的名称由系统确定的，不能更改
       String name = Thread.currentThread().getName();//得到线程的名称
        System.out.println(name);

        //创建thread对象
        TestThread tt= new TestThread();
        //设置线程的名称
        tt.setName("子线程1");
        //开启任务
        tt.start();
for (int i = 0; i < 5; i++) {
          System.out.println("main:"+(i+1));
        }

运行结果：

33.PNG

34.PNG

在这里我们的for循环是在主线程里面，主线程里面的代码是由上往下执行。当执行到tt.start()的时候，它会开启一个新的线程去执行，程序运行继续往下走。但在这里存在着问题，tt.start()和for循环存在一个资源的抢夺。如果是主线程抢到资源，就会执行for循环。相反，则是tt.start()执行。

2.实现Runnable接口实现run方法

a.创建任务创建类实现Runnable接口
b.使用Thread为这个任务分配线程
c.开启任务start

//这里的类YJXThread相当于一个任务，实现了Runnable接口
class YJXThread implements Runnable{
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i=1; i <=100;i++) {
            System.out.println(name + ":" + i);
        }
    }
}

第二种方式有4个使用方式：
使用方式1：

//1.接口 抽象方法
        //创建一个任务：创建一个类实现Runnable接口
      YJXThread pt = new YJXThread();

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

        Thread t2 = new Thread(pt);
        t2.setName("子线程2");
        t2.start();

运行结果：

GIF.gif5.gif

在这里可以看到创建了2个子线程。他们一起输出1-100.但这里是有区别的。你看子线程1从1开始输出到6就停止了，接着的是子线程2从1到10就停止，再接着的是子线程1，依次这样，直到它们各输出到100.为什么会这样呢？
这是因为有一个join:让当前这个线程阻塞等join的线程执行完毕在执行。

 @Override
    public void run() {
        String name = Thread.currentThread().getName();
        for (int i = 1; i <= 10; i++) {
            System.out.println(name + ":" + i);
            if (this != MyClass.tt2) {
            if (i==10) {
                try {
                    MyClass.tt2.join();//让当前这个线程阻塞 
                                      //等join的线程执行完毕在执行。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            }
            }
            super.run();
        }

第二种使用方式

 //这个任务只需执行一次
       Thread t= new Thread(new Runnable() {
           @Override
           public void run() {
               String name = Thread.currentThread().getName();
               for (int i = 1; i <= 100; i++) {
                  System.out.println(Thread.currentThread().getName()+":"+i);
               }
           }
       });
       t.setName("子线程1");
       t.start();

        Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                for (int i = 1; i <= 100; i++) {
                  System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        });
        t2.setName("子线程2");
        t2.start();

第三种方式：

 //3.创建线程的同时 直接开启线程任务
        //不需要操作线程对象本身
    new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=1; i <=100;i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }).start();

第四种方式：

//使用Lambda表达式
        //不建议：阅读性太差
        new Thread(()->{
            for (int i=1; i <=100;i++) {
                System.out.println( Thread.currentThread().getName()+":" + i);
            }
        });

第二种创建线程方式的几种使用方式的运行结果都差不多，只是存在着结果的差异，这是因为线程的运行结果是不唯一的。

6.gif

线程同步的两种方式：

线程安全：

多个线程操作同一个资源，线程无法确定自己什么时候被阻塞
容易导致数据错误

35.PNG

第一：这时候我们可以使用synchronized同步代码块

synchronized Lock 实现加锁解锁
synchronized 同步监听器需要一把锁
任何一个对象都有一把锁
如果多个线程操作同一个代码块，并且需要同步
那么必须操作同一个对象/同一个对象的同一把锁
1.同步代码块

 synchronized(监听器/对象/对象的一把锁){
     需要同步的代码
  }

  @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //首先判断有没有票
            synchronized (obj) {
                //需要同步的代码
                if (num > 0) {
                    System.out.println(name + "出票" + (101 - num));//线程第几张票打印出来了
                    num--;
                    try {
                        condition.signal();
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //唤醒其他线程执行
                        notify();
                    }
                } else {
                    break;
                }
            }

2.同步方法同步监听器是当前对象本身

必须确保多个对象调用的同步方法时操作的同一个对象
public synchronized void test()
本质就是同步代码块等价于

 synchronized (this){
       test();
   }

36.PNG

第二种：使用ReentrantLock同步

 //加锁
            lock.lock();
                //需要同步的代码
                if (num > 0) {
                    System.out.println(name + "出票" + (101 - num));//线程第几张票打印出来了
                    num--;
                    try {
                        condition.signal();
                       condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        //唤醒其他线程执行
                        notify();
                    }
                } else {
                    break;
                }
                //解锁
            lock.unlock();
            }

Java中 的多线程（Thread）

技术：