JAVA-（多线程-进程和线程、线程的生命周期、创建线程的方法、

---

心得体会

• 今天主要学习了多线程。多线程的知识点还挺更多的，但是如果将知识模块细化，就不会太困难。中午的时候我花了点时间复习了一下上午的内容，发现下午在设计到上午的只知识点时没有感到很迷茫，有些问题能够回答出来。但是下午的线程安全知识点让我挺费脑筋的。

---

今日知识点

• 1.进程和线程

• 2.线程的生命周期

• 3.创建子线程的原因

• 4.创建线程的方法

• 5.线程安全

• 6.线程入门小demo

---

1.进程和线程

• 进程与线程的定义

进程:

是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元,系统会为这个进程发配独立的内存资源。
例如：正在运行的 QQ、IDE、浏览器就是进程

线 程:

具体执行任务的最小单位 .就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。

• 进程与线程的联系

序号	进程与线程的联系
（1）	一个进程最少拥有一个线程--主线程--- 运行起来就执行的线程
（2）	线程之间是共享内存资源的（这个内存资源是由进程申请的）
（3）	线程之间可以通信（进行数据传递：多数为主线程和子线程）
（4）	每一个线程都有自己的运行回路

2.线程的生命周期

线程的生命周期	定义
新建(NEW )	线程刚被创建好，从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态
就绪 (RUNNABLE）	线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度，只要抢到时间片就可以运行这个线程
运行（RUNNING）	就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态
等待/阻塞/睡眠（BLOCKED）	在一个线程执行了sleep（睡眠）、wait(等待）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态
终止(TERMINATED)	run（）方法完成后或发生其他终止条件时就会切换到终止状态

图例：

DJ9SFG5YXY6_)~QV}DW2_2N.png

3.创建子线程的原因

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

4.创建线程的方法

• 创建线程的第一种方法---继承Thread类实现run方法

步骤：

① 定义类继承Thread;
② 复写Thread类中的run方法；（目的：将自定义代码存储在run方法，让线程运行）

③调用线程的start方法：(该方法有两步：启动线程，调用run方法)

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

        // main方法里面执性的代码 是在主线程里面执行的
        String name=Thread.currentThread().getName();//创建一个对象，获取当前线程的名称赋给该对象
        System.out.println(name);//打印线程的名称

       //创建第一个线程
        TestThread tt=new TestThread(); //创建Thread的对象
        tt.setName("子线程1"); //设置线程的名称
        tt.start();// //开启任务

        //创建第二个线程
        TestThread tt2=new TestThread();
        tt2.setName("子线程2");
        tt2.start();

    }
}

// 定义一个类继承Thread
class TestThread extends Thread{
    //复写Thread类中的run方法，方法里面具体需要执行的代码
    @Override
    public void run() {
        String name=Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
        for(int i=0;i<100;i++){
            System.out.println(name+":"+(i+1));
  }
        super.run();
    }
}

20190818_161717.gif
试思考：如果main函数里面再加一个tt.start();,结果会如何？

        TestThread tt=new TestThread(); //创建Thread的对象
        tt.setName("子线程1"); //设置线程的名称
        tt.start();// //开启任务
        tt.start();

回答：会出错，因为：对同一个线程不能同时开启

进阶小demo：

将上诉demo进行完善，实现当子线程1执行到10后，子线程1就被阻塞，然后开始执行线程2直至线程2结束，即线程2执行到100，然后才执行线程1

public class Myclass {
 static TestThread tt2;
  public static void main(String[] args) {
//        main方法里面执性的代码 是在主线程里面执行的
      String name = Thread.currentThread().getName();
      System.out.println(name);
      //创建Thread的对象
      TestThread tt = new TestThread();
      //设置线程的名称
      tt.setName("子线程1");
      //开启任务
      tt.start();//只有这一句话耽误了一点时间

      tt2 = new TestThread();
      //设置线程的名称
      tt2.setName("子线程2");
      //开启任务
      tt2.start();
}
}
    class TestThread extends Thread {
  //实现run方法
  //方法里面具体需要执行的代码
  @Override
  public void run() {
      String name = Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
//        System.out.println(name);
      for (int i = 1; i < 101; i++) {
          System.out.println(name + ":" + (i ));
          if (this != Myclass.tt2) {//判断是否是子线程1
              if (i == 10) {
                  try {
                      Myclass.tt2.join();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
      super.run();
  }
}

L2@A}}Z~8)JO9}7RK_3@E_T.png
上面一段demo中所用到的方法如下：

方法	作用
join()	让当前这个线程阻塞 等join()的线程执行完毕再执行
setName()	设置线程名称
getName()	获取线程名称
currentTHread()	获取当前运行的线程对象

---

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

注意事项： 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

步骤：
① 创建任务： 创建类实现Runnable接口
② 使用Thread 为这个任务分配线程
③ 开启任务Start()

使用方式1---创建一个类实现Runnable接口，使用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{//创建了一个PXDThread类并实现Runnable接口
    public void run() {
        for(int i=0;i<=100;i++) {
            System.out.println(Thread.currentThread().getName()+" :"+i);
        }
    }
}

（在main函数里）
使用方式2---这个任务只需要使用一次

public class Myclass {
    public static void main(String[] args) {
         Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;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() {
                for(int i=0;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=0;i<=100;i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }

            }
        }).start();

**使用方式4--使用Lammbda表达式（不建议：阅读性太差）

  new Thread(()->{
            for(int i=0;i<=100;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }).start();

5.线程安全

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

• 要编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享的和可变的状态的访问。一个对象是否需要是线程安全的，取决于它是否被多个线程访问。要使得对象是线程安全的，需要采用同步机制来协同对象可变状态的访问。当多个线程访问某个状态变量并且其中一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。

• 同步代码块的两种方式

我们以卖火车票为例：

image.png
首先：我们来看一个小例子：

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         t2.start();
   }
}
//用于买票的任务(共享-》静态）
class Ticket implements  Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;

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

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
           System.out.println(name + "出票：" +i);
                }
            }
       }

得到的结果是：上海出票100，重庆出票100，并没有达到 重庆和上海共用100票的目的

• 同步代码块的第一种方式---synchronized（参数就是一个监听器）

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

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         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 = 0; i <= 100; i++) {
            synchronized (obj) {
                if (num > 0) {
                    System.out.println(name + "出票：" + num);
                    num--;
                    try {
                        //当前线程等待
                        obj.notify();
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //通知其他线程执行

                    }
                } else {
                    break;
                }
            }
        }
    }
}

• 同步代码块的第二种方式---ReentrantLock

public class Myclass {
    public static void main(String[] args) {
       Ticket ticket=new Ticket("重庆");
         Thread t1=new Thread(ticket);
         t1.start();
         Ticket ticket1=new Ticket("上海");
         Thread t2=new Thread(ticket1);
         t2.start();
   }
}
class Ticket implements  Runnable {
    //定义所有车票的数量
    public static int num = 100;
    String name;

    public Ticket(String name) {
        this.name = name;
    }
    static ReentrantLock lock=new ReentrantLock();
 @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
           lock. lock();//加锁
                if (num > 0) {
                    System.out.println(name + "出票：" + num);
                    num--;

                } else {
                    break;
                }
                lock.unlock();//解锁
            }
        }
    }

20190818_210342.gif

• 6.线程入门小demo

image.png

public class Person implements Agent.AgentInterface {//实现了Agent.AgentInterface接口
    public void needHouse(){
        Agent xw=new Agent();
        xw.target=this;//表明吧对象返回给谁
        xw.start();
    }
    @Override
    public void callBack(String desc) {
        System.out.println("我是小王，接收到你的数据了："+desc);
    }
}

//1.继承Thread,重写run方法
public class Agent extends Thread{

    AgentInterface target;
    @Override
    public void run() {
        System.out.println(Thread.currentThread());
        System.out.println("开始找房子");
        System.out.println("----------");
        System.out.println("房子找到了");

        target.callBack("房子在西南大学");
        super.run();
    }
    public interface AgentInterface{
        void callBack(String desc);//把找到的房源信息返回
    }
}

public class Myclass {
    public static void main(String[] args) {
            Person zs = new Person();
            zs.needHouse();
    }
}

image.png