# java-thread

**Repository Path**: xccit/java-thread

## Basic Information

- **Project Name**: java-thread
- **Description**: Java多线程编程细微入门笔记
- **Primary Language**: Java
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-06-08
- **Last Updated**: 2023-06-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Java多线程

> 线程与任务的关系:
>
> 线程没有任务执行是没有意义的.

## 实现方式

### 1.继承Thread类(常用)

#### 1.1Thread构造器

> 无参构造:不需要指定任务
>
> 有参构造:直接指定线程的任务

##### 1.1.1 无参构造(无意义,不指定任务)

```java
public Thread()
```

##### 1.1.2有参构造(指定任务)

```java
public Thread(Runnable target)
```

#### 1.2执行流程

##### 1.2.1创建Thread对象并指定任务

```java
Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
            }
        });
```



##### 1.2.2调用start()方法开启线程,进入就绪状态,等待CPU分配资源

```java
thread.start();
```

##### 1.2.3拿到CPU资源后,开始执行任务

> 拿到CPU资源后,调用Thread本身的run()开始执行任务

![image-20230608105950332](Java%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets/image-20230608105950332.png)

> target:创建Thread对象时,传入的任务,本质上是一个Runnable接口,定义在Thread的成员变量中,run()中校验target不为空时,执行target本身的run()来执行任务的逻辑

### 2.实现Runnable接口(常用)

### 3.实现Callable接口(需要接收一些返回值时)

### 3.继承和实现的区别

#### 3.1 继承Thread类

> 代码灵活性差,任务与线程对象绑定在一起,任务与对象高耦合

```java
/**
 * @author CH_ywx
 * @date 2023-06-08
 * @description 继承Thread类实现
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("----MyThread:"+i);
        }
    }
}
```

```java
public class TestMyThread {
    public static void main(String[] args) {
        new MyThread().start();
    }
}
```

#### 3.2 实现Runnable接口

> 实现解耦合,解决了继承Thread类的高耦合问题
>
> 此处使用组装对象方式巧妙解决了任务与线程的高耦合问题
>
> 通常正式开发环境中使用这种方式进行多线程开发

```java
/**
 * @author CH_ywx
 * @date 2023-06-08
 * @description 实现Runnable
 */
public class Runnable1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("Runnable1======>"+i);
        }
    }
}
```

```java
/**
 * @author CH_ywx
 * @date 2023-06-08
 * @description 实现Runnable
 */
public class Runnable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("Runnable2=====>"+i);
        }
    }
}
```

```java
public class TestRunnable {
    public static void main(String[] args) {
        Runnable1 runnable1 = new Runnable1();//任务1
        Thread thread = new Thread(runnable1);//组装任务
        Runnable2 runnable2 = new Runnable2();//任务2
        Thread thread1 = new Thread(runnable2);//组装任务
        thread.start();
        thread1.start();
    }
}
```

## 总结

### 1.多线程执行的先后顺序?

> 执行没有固定顺序,线程之间都要与CPU争夺资源,谁拿到CPU资源谁就去执行,以上代码实例的执行结果中,任务1与任务2的顺序也是相互掺杂的

![image-20230608115450649](Java%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets/image-20230608115450649.png)
>>>>>>> f69511d (JAVA多线程)