[java进阶]——多线程Thread类，处理并发异常的方法

键盘敲烂，年薪30万

目录

一、理解进程与线程

二、Thread类

三、自定义线程的三种实现方式

四、多线程应用场景

五、解决并发问题的方法

5.1 synchronized()关键字 - 同步代码块

5.2使用lock锁

---

一、理解进程与线程

运行一个程序占用一个进程，程序中的子任务是线程，故一个进程可以有多个线程。

例如银行每一个窗口都在处理业务，但所有窗口存和取的钱都放在该银行保险柜里

 当下最火的并发编程

一个线程在运行时是会占用cpu内存的，如果该线程正待等待用户输入数据，那么用户不输入，cpu就要一直被占用，为了提高cpu的利用率，有了并发执行，线程抢占cpu，每个线程被选中执行的概率是随机的，这叫线程调度

拓展个概念：

每个线程被cpu选中执行的概率是随机的，这个过程叫做线程的调度，线程调度器会根据线程的优先级、执行状态、等待时间等因素来决定哪个线程可以被执行，从而实现对CPU资源的有效利用。

4核8线程的意思是有四个独立的核心一个核心有2个线程，每个任务可以在不同的核心上执行，每个任务的一个子任务就可以看作一个线程。

mian函数也是一个线程。

二、Thread类

java把线程相关的属性和方法封装到Thread类里面，可以利用该类创建线程对象

start 开启线程

setname 设置名称

getname 获取名称

sleep 休眠多少毫秒(静态)

currentThread 获取当前线程(静态)

setPriority 设置线程的优先级

setDaemon 设置为守护线程

初步感受进程代码

class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("我是另一个线程");
            //休眠2秒
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        while (true){
            Thread.sleep(2000);//休眠两秒
            System.out.println("main线程");
        }


    }
}

main线程和另一个线程交替执行。

三、自定义线程的三种实现方式

3.1创建一个类继承Thread子类

重写里面的run方法 - 线程要处理的任务

创建该类

public class MyThread extends Thread{
    @Override
    public void run() {
        //线程要执行的方法
    }
}
public static void main(String[] args) {
        /*
        * 线程的第一种创建方式thread
        * 1.创建一个类继承thread
        * 2.重写里面的run方法
        * 3.创建该类
        *
        *
        * */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

    }

3.2定义一个runable接口的实现类

重写run方法

创建runable实现类

据实现类创建Thread类

public class MyRun implements Runnable{
    @Override
    public void run() {
        //线程要执行的方法
    }
}
public static void main(String[] args) {
        /*
        * 线程的第二种实现方式
        * 1.定义一个类实现runable接口
        * 2.创建该接口的实现类
        * 3.创建thread类，把实现类传入
        * */
        MyRun myRun = new MyRun();
        Thread thread = new Thread(myRun);
    }

3.3定义一个类实现callable接口

重写call方法

创建callable实现类 - 任务

创建futuretask对象 -  管理线程结果

创建thread对象 - 创建线程

public class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        //线程要执行的方法
        return total;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程的第三种实现方式
        * 1.定义一个类实现callable接口
        * 2.重写里面的call方法
        *
        * 3.创建mycallable对象 - 任务
        * 4.创建futuretask对象 - 管理线程结果
        * 5.创建thread对象 - 创建线程
        *
        * */
        MyCallable myCallable = new MyCallable();
        FutureTask integerFutureTask = new FutureTask(myCallable);
        Thread thread = new Thread(integerFutureTask);

    }

3.4应用场景总结

如果要用到线程的处理结果(返回值)，就用第三种实现方法

如果你想继承其它子类，用第二种或第三种

如果是单纯的继承Thread类，用第一种

因为java只支持单继承，不支持多继承

四、多线程应用场景

用多线程模拟三个窗口卖100张票的过程

思路：1.定义一个线程类  2.重写里面的run方法模拟买票  3.创建3个对象模拟3个窗口

public class Mythread extends Thread {
    static int ticket = 0;//静态修饰
    @Override
    public void run() {
        while (ticket++ < 100) {
                try {
                    //休眠1秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "窗口正在卖第" + ticket + "张票");
            }
    }
}
public class Test1 {
    public static void main(String[] args) {
        //实现三个窗口卖100张票的
        Thread t1 = new Mythread("窗口1");
        Thread t2 = new Mythread("窗口2");
        Thread t3 = new Mythread("窗口3");
        t2.start();
        t1.start();
        t3.start();
}

我们把代码跑起来

这和现实生活中的完全不一样，这其实引发了并发异常，简单说一下，开启了3个进程，每个进程被cpu选中是随机的，当线程1被选中并且代码运行到while循环里，cpu又去执行线程2，还有可能去执行线程三等等，所以导致同时卖出了第三张票

五、解决并发问题的方法

5.1 synchronized()关键字 - 同步代码块

原理分析：

给可能发生异常的代码加上锁之后，其他线程只能等待该线程执行完释放该锁。

代码分析：

synchronized()

括号要求是一个对象，什么类型都可，但针对该类必须唯一，也就是这把锁是管理该类的一把锁，可以是静态修饰得对象，可以是Mythread得字节码文件。

还是以买票举例

public class Mythread extends Thread {
    static int ticket = 0;//静态修饰
    @Override
    public void run() {
        while (ticket++ < 100) {
            //synchronized()括号里写一个锁对象，必须针对该类唯一
            synchronized (Mythread.class) {
                try {
                    //休眠1秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "窗口正在卖第" + ticket + "张票");
            }
        }
    }
}

把可能引发并发异常的代码抽象成方法 用synchronized修饰

这是的锁对象会默认创建，如果是静态的方法，该对象是ths 如果是非静态，该对象是该类的class文件

@Override
    public void run() {
        while (ticket++ < 100000) {
            //同步方法
            method();
        }
    }

    private synchronized void method() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "窗口正在卖第" + ticket + "张票");
    }

5.2使用lock锁

获取静态锁对象

调用lock方法把并发代码锁起来

并发代码用try-catch包裹

释放锁放在finally代码块里

public class MyThread extends Thread{
    static int ticket = 0;
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while(ticket++ <= 100){
            lock.lock();
            try {
                if(ticket <= 100){
                    System.out.println(Thread.currentThread().getName() + "窗口卖出第" + ticket + "张票");
                    Thread.sleep(10);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }
}

这样修改后的买票系统就能正常实现啦

注意：不要使用锁嵌套，可能出现死锁。看下面代码

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 acquired lock1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 acquired lock2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2 acquired lock1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

总结

为什么会有并发异常，并发异常会导致什么后果

如何解决并发异常