概述

1.进程&线程

进程：是正在运行的程序
是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

• 单线程:一个进程如果只有一条执行路径，则称为单线程程序
• 多线程:一个进程如果有多条执行路径，则称为多线程程序

2.并行&并发

并行：在同一时刻，有多个指令在多个CPU上同时执行
（一边吃面包一边写字）

并发：在同一时间间隔，有多个指令在单个CPU上交替执行。
（在8.00-8.30时间段内，先吃面包再写字）

线程创建方式

1.第一种：继承Thread类

步骤：
（1）定义一个子类（MyThread）继承线程类java.lang.Thread，重写run()方法

（2）创建这个类（MyThread）的对象

（3）调用线程对象的 start( ) 方法启动线程（启动后还是执行run方法的）

注意：
Q1：为什么要重写run()方法?
因为run()是用来封装被线程执行的代码

Q2：为什么不直接调用了run方法，而是调用start启动线程 ？
直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。只有调用start方法才是启动一个新的线程执行。

e.g
写法1完整版

/**1、定义一个线程类继承Thread类 */
class MyThread extends Thread{
    /**
       2、重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
    
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        MyThread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

写法二匿名内部类
上述写法比较复杂，可以直接简化：

new Thread()
        {
            @Override
            public void run()
            {
                for(int i=0;i<50;i++) {
                    System.out.println(getName() + ":" + i);
                }
            }
        }.start();

2.第二种：实现Runnable接口

步骤：
（1）定义一个线程任务类MyRunnable类实现Runnable接口，重写run()方法

（2）创建MyRunnable任务对象

（3）创建Thread类的对象，把MyRunnable对象作为构造方法的参数（即把MyRunnable任务对象交给Thread处理）

（4）调用线程对象的start()方法启动线程

e.g.
写法一完整版：

public class ThreadDemo2 {
/**
   1、定义一个线程任务类 实现Runnable接口
 */
class MyRunnable  implements Runnable {
    /**
       2、重写run方法，定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        
        // 5、启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}

写法二匿名内部类：

new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                System.out.println("实现runnable接口");
            }
        }).start();
        
// 或者直接lambda表达式
new Thread(() -> System.out.println("实现runnable接口")).start();

3.Callable、FutureTask接口

jdk5新增的创建方式

4.线程创建的三种方式对比

相比直接继承Thread类，实现Runnable接口有如下好处：

• 避免Java单继承限制，但是通过实现Runnable接口，可以在同一个类中实现多个接口。这使得线程类能够继续扩展其他类的功能，而不仅限于Thread类。

• 提高代码的重用性：通过实现Runnable接口，线程类可以将线程的执行逻辑与线程的管理逻辑分离。

• 分离线程与任务：通过实现Runnable接口，线程类只负责线程的管理，而不关注具体的任务逻辑。

Thread常用方法

1.构造器

2.设置和获取线程名称

方法	含义
String setName(String name)	将此线程的名称更改为等于参数name
String getName（ ）	返回此线程的名称
static Thread currentThread( )	返回对当前正在执行的线程对象的引用

3.线程调度

4.线程控制

方法	含义
static void sleep(long millis)	使当前正在执行的线程停留(暂停执行)指定的毫秒数
void join(）	等待这个线程死亡
void setDaemon(booleanon)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

5.线程生命周期

线程安全

1.线程安全问题出现的原因？

（1）存在多线程并发

（2）同时访问共享资源

（3）存在修改共享资源

2.解决方案——线程同步

加锁：加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

加锁方式：

（1）同步代码块

（2）同步方法