多线程学习

---

前言

本次总结我们将大致了解下多线程相关概念，如：进程与线程、同步与异步、并发与并行等。以及多线程的创建方法，以及多线程带来的线程不安全的解决方法。当然只能是基于初学者给出的了解

一、进程与线程

1. 进程

• 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

2. 线程

• 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程

• 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

• 线程的生命周期分别六个：新建、就绪&运行、阻塞、等待、计时等待、销毁。
  

二、线程调度

1. 分时调度

• 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

2. 抢占式调度

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

三、同步与异步

同步: 排队执行 , 效率低但是安全.
异步: 同时执行 , 效率高但是数据不安全.

四、并发与并行

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

五、多线程的创建方法

1. 继承 Thread 类

不推荐本方式来创建线程，原因显而易见：java 不支持多继承，如果继承了 Thread 类就不能再继承其他类了。
ps: 但是可以使用匿名创建的方式使用。
如(new Thread(run方法)).start()

public class MyThread extends Thread {
 
    //run方法就是线程要执行的任务方法
 
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}

//创建一个子类对象
MyThread t = new MyThread() ;
//调用start()
t.start();

2. 实现 runnable 接口

实现接口来创建线程是目前推荐的一种方式，原因也很简单：一个类可以实现多个接口。实现 Runnable 接口并不影响实现类再去实现其他接口。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}

//1 创建一个任务对象
MyRunnable r = new MyRunnable();
//创建一个线程并给他一个任务
Thread t = new Thread(r);
//启动线程
t.start();
        

3. 实现 Callable 接口

3.1 Runnable 与 Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

3.2 Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不能抛出

3.3 Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
(还未用到Callable，所以此处不做总结，后续用到再进行补充)

六、线程安全

线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。如课上的例子，多个线程执行卖票操作时，出现了票数余额为负数的情况，原因是在票数还没有自减的时候，其他进程加入卖掉了票。
解决方法：当一个线程在操作ticket时，其他线程不能参与进来，直到此线程的生命周期结束，在java中，我们通过同步机制，来解决线程的安全问题。

方法一：同步代码块

Synchronized（同步监视器）{
//需要被同步的代码
}

public class Demo {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1  同步代码块
        //格式：synchronized（锁对象）{
        //
        //      }
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
 
    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }
 
                }
            }
        }
    }
}

方法二：使用同步方法。对方法进行synchronized关键字修饰

• 将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。
• 对于runnable接口实现多线程，只需要将同步方法用synchronized修饰
• 而对于继承自Thread方式，需要将同步方法用static和synchronized修饰

//线程同步synchronized
 
public class Demo {
    public static void main(String[] args) {
        Object o = new Object();
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
 
    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
 
            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;
 
        }
    }
}
 

方法三 ：显示锁lock。创建一个锁对象，参数为true表示公平锁，默认是false 不是公平锁

private Lock l = new ReentrantLock(true);
在需要被同步的代码前痛哟锁对象调用lock()方法上锁，在其后用unlock()方法解锁。

public class Demo {
    public static void main(String[] args) {
        Object o = new Object();
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
 
    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        //参数为true表示公平锁    默认是false 不是公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                    l.unlock();
            }
        }
    }
}

部分转载自https://blog.csdn.net/qq_16657805/article/details/108887037