Java多线程,线程的生命周期,线程的创建方式,线程安全。

灰太狼 2020-05-29 19:50 1195阅读 1赞

### 1.进程和线程

- #### 进程与线程的定义

##### 进程:

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

##### 线 程:

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

- #### 进程与线程的联系

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

### 2.线程的生命周期

图例：

![](/images/1590781559082.png)

### 3.创建子线程的原因

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

### 4.创建线程的方法

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

> **步骤：**

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

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

```java
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();
    }
}
```

![](/images/1590781637060.webp)

**试思考：****`tt.start();`**

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

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

##### 进阶小demo：

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

```java
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();
  }
}
```

![](/images/1590781679799.png)

**上面一段demo中所用到的方法如下：**

------

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

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

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

**使用方式1---创建一个类实现Runnable接口，使用Thread来操作这个任务**

```java
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---这个任务只需要使用一次**

```csharp
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---创建线程的同时 直接开启线程任务，不需操作线程对象本身**

```csharp
    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表达式（不建议：阅读性太差）

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

### 5.线程安全

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

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

- #### 同步代码块的两种方式

**我们以卖火车票为例：**

![](/images/1590781718012.png)

**首先：我们来看一个小例子：**

```java
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（参数就是一个监听器）

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

```dart
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

```csharp
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();//解锁
            }
        }
    }
```

![](/images/1590781745675.webp)

- ### 6.线程入门小demo

![](/images/1590781783214.png)

```java
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);
    }
}
```

```csharp
//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);//把找到的房源信息返回
    }
}
```

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

![](/images/1590781818006.png)