关于多线程的基础知识

一：多线程

1.并发与并行
①并行：指两个或多个事件在同一时刻发生（同时执行）。

②并发：指两个或多个事件在同一个时间段内发生。
（交替执行）

2.线程与进程
①进程：是指内存中正在运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程。进程是系统运行程序的基本单位。系统运行一个程序即是一个进程从创建、运行到消亡的过程。
②线程：进程内部的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程（主线程）。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
例子：
系统中运行的一个进程：迅雷软件（1.线程1下载jdk文档 2.线程2下载战狼2 3.线程3下载QQ软件）

3.主线程
①：java中的主线程就是执行主( main )方法的线程。我们前期书写的java程序都是单线程的程序，执行是从main方法开始，从上往下依次执行。

4.多线程
①：Java虚拟机允许应用程序同时执行多个执行线程。 所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的线程任务。Java中可以通过继承Thread类来创建并启动多线程。
②：多线程的第一种创建方式：
1.创建子类，继承Thread线程类
2.在当前子类中重写Thread类中的run()方法：线程任务，需要多线程执行代码
3.创建Thread子类对象
4.通过调用start()方法启动线程

例子：
自定义类：
// 1、定义类并声明为Thread类的子类
public class MyThread extends Thread {
// 2、 在类中重写run方法，即线程任务
public void run() {
// 循环打印 1- 20
for( int i = 1; i <= 20; i++ ) {
System.out.println("run i = " + i );
}
}
}

测试类：
// 演示线程的第一种创建方式
public class ThreadDemo {
public static void main(String[] args) {
// 3、创建线程的子类对象
MyThread mt = new MyThread();
// 4、通过start()方法启动线程任务
mt.start();

    // 循环打印1-20
    for( int i = 1; i <= 20; i++ ) {
        System.out.println("main i = " + i );
    }
}

}

执行结果：俩个线程的结果交替展示

③：多线程的第二种创建方式：
1.声明一个实现Runnable接口的实现类
2.在实现类中重写run()方法。指定线程任务
3.创建实现类对象
4.创建Thread对象，并将实现类对象作为参数传递给Thread的构造方法中
5.启动线程。start()

例子：
自定义类
// 创建Runnable接口的实现类
public class MyRunnable implements Runnable{
// 重写run方法 即线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println( Thread.currentThread().getName() + " "+i);
}
}
}

public class RunnableDemo {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread( mr, “小强” );
// 启动线程任务
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("旺财 " + i);
}
}
}

二：多线程原理，安全
1.多线程执行原理图解

2.线程安全

①线程安全的问题
多个线程要操作同一个共享的资源。多个线程操作共享资源时，因为线程的调度问题，会产生各种安全问题。
1.会产生票数一样的
2.会产生中间没有票数的
3.会产生负数票的
归根结底：就是一个线程还没有将线程任务完成，下一个线程就进来了，导致的线程安全问题

②线程安全解决办法（3种方式加锁–等一个线程操作完成，另一个在执行）

1. 同步代码块。

语法：
synchronized( 同步锁 ) {
代码块中放操作共享数据的代码。
}

案例：

// 创建售票任务 添加同步代码块

public class Ticket implements Runnable {
// 定义变量，模拟电影票
private int ticket = 100;
// 创建锁对象
private Object lock = new Object();
// 2、 创建线程任务，模拟窗口售票

public void run() {
    // 死循环模拟窗口一直在售票             
    while( true ) {
        // 对操作共享语句的代码，添加同步代码块          
        synchronized ( lock ) {
            // 判断是否还有余票           
            if( ticket > 0 ) {                
                // 获取线程（窗口）的名字
                String name = Thread.currentThread().getName();
                // 输出语句模拟车票售出
                System.out.println( name + "正在售出：" + ticket );
                // 使用线程睡眠模拟出票的时间
                try {Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // 电影票售出后需要将当前售出的票从总票中减除
                ticket--;
            }
        }
    }
}

}

2. 同步方法。

语法：
public synchronized void 方法名( 参数 ){
可能会产生线程安全问题的代码；
}

案例：
// 创建售票任务 同步方法
public class Ticket implements Runnable {
// 定义变量，模拟电影票
private static int ticket = 100;

// 2、 创建线程任务，模拟窗口售票
public void run() {
    // 死循环模拟窗口一直在售票
    while (true) {
        // 调用同步方法
        payTicketStatic();
    }
}


// 非静态同步方法
public synchronized void payTicket(){       
        // 判断是否还有余票
        if (ticket > 0) {
            // 获取线程（窗口）的名字
            String name = Thread.currentThread().getName();
            // 输出语句模拟车票售出
            System.out.println(name + "正在售出：" + ticket);

            // 使用线程睡眠模拟出票的时间
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 电影票售出后需要将当前售出的票从总票中减除
            ticket--;          
    }
}

// 静态同步方法
public static synchronized void payTicketStatic(){        
        // 判断是否还有余票
        if (ticket > 0) {
            // 获取线程（窗口）的名字
            String name = Thread.currentThread().getName();
            // 输出语句模拟车票售出
            System.out.println(name + "正在售出：" + ticket);

            // 使用线程睡眠模拟出票的时间
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 电影票售出后需要将当前售出的票从总票中减除
            ticket--;         
    }
}

3. 锁机制（lock的用法，比上面俩种的用法更广泛）

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
java.util.concurrent.locks.Lock;
接口不能直接创建对象，可以使用多态new实现类对象。ReentrantLock
接口中提供了两个方法：
lock(): 获取锁
unlock(): 释放锁

为了防止程序在执行的过程中遇到异常，导致锁无法释放，我们可以使用
try{}fianlly{} 代码块来解决这个问题
try代码块中书写正常执行的代码
finally代码块中书写释放锁的方法，这样在任何情况下释放锁的代码都会执行

*/
// 创建售票任务 添加Lock锁对象
public class Ticket implements Runnable {
// 定义变量，模拟电影票
private int ticket = 100;
// 创建Lock锁对象
Lock lock = new ReentrantLock();

// 2、 创建线程任务，模拟窗口售票
public void run() {
    // 死循环模拟窗口一直在售票
    while (true) {
        // 使用lock() 方法上锁
        lock.lock();
        try{
            // 判断是否还有余票
            if (ticket > 0) {
                // 获取线程（窗口）的名字
                String name = Thread.currentThread().getName();
                // 输出语句模拟车票售出
                System.out.println(name + "正在售出：" + ticket);

                // 使用线程睡眠模拟出票的时间
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 电影票售出后需要将当前售出的票从总票中减除
                ticket--;
            }
        } finally { // 不管程序是否出现异常，最终都需要释放锁
            // 使用unlock()方法释放锁
            lock.unlock();
        }
    }
}

}