多线程相关知识详解！

最新推荐文章于 2023-01-18 11:28:13 发布

吃饭睡觉改bug

最新推荐文章于 2023-01-18 11:28:13 发布

阅读量411

点赞数 3

分类专栏：多线程文章标签： java 多线程

本文链接：https://blog.csdn.net/dekulugu/article/details/108754623

版权

多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

多线程相关知识详解

进程和线程是什么？

进程：在我们的电脑上有很多单独运行的程序，这每一个程序都有一个独立的进程，进程之间相互独立，比如我们电脑上的qq，微信，电脑管家等。
线程：进程想执行任务就需要依赖线程，一个进程中至少有一个线程。那么什么是多线程呢？先来了解一下串行和并行。
- 串行：就是一个线程执行执行多条任务时，必须先执行完A，然后再执行B，最后执行C。
- 并行：比如在下载多个文件时开启多条线程，多个文件同时进行下载，这里是严格意义上的，在同一时刻发生的，并行在时间上是重叠的。
那么再针对多线程来说，就好比我们使用训练下载文件的时候可以同时下载多个文件，按照单线程来讲就必须下载完一个文件后再开始下载另一个文件。

线程的生命周期

新建：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；
就绪：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；
运行：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。
等待/阻塞/睡眠：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。
终止：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

创建线程的多种方式

1、继承Thread类：

定义类继承Thread
复写Thread类中的run方法；
目的：将自定义代码存储在run方法，让线程运行
调用线程的start方法：
该方法有两步：启动线程，调用run方法。

public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建两个线程
        ThreadDemo td = new ThreadDemo("zhangsan");
        ThreadDemo tt = new ThreadDemo("lisi");
        //执行多线程特有方法，如果使用td.run();也会执行，但会以单线程方式执行。
        td.start();
        tt.start();
        //主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("main" + ":run" + i);
        }
    }
}
//继承Thread类
class ThreadDemo extends Thread{

    //设置线程名称
    ThreadDemo(String name){
        super(name);
    }
    //重写run方法。
    public void run(){
        for(int i = 0; i < 5; i++){
        System.out.println(this.getName() + "：run" + i);　　//currentThread()  获取当前线程对象（静态）。  getName（） 获取线程名称。
        }
    }
}

2、实现Runnable接口：接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

定义类实现Runnable接口
覆盖Runnable接口中的run方法
将线程要运行的代码放在该run方法中。
通过Thread类建立线程对象。
将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

public class RunnableDemo {
    public static void main(String[] args) {
        RunTest rt = new RunTest();
        //建立线程对象
        Thread t1 = new Thread(rt);
        Thread t2 = new Thread(rt);
        //开启线程并调用run方法。
        t1.start();
        t2.start();
    }
}

//定义类实现Runnable接口
class RunTest implements Runnable{
    private int tick = 10;
    //覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
    public void run(){
        while (true) {
            if(tick > 0){
                System.out.println(Thread.currentThread().getName() + "..." + tick--);
            }
        }
    }
}

3、通过Callable和Future创建线程：

创建Callable接口的实现类，并实现call()方法，改方法将作为线程执行体，且具有返回值。
创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值
使用FutureTask对象作为Thread对象启动新线程。
调用FutureTask对象的get（）方法获取子线程执行结束后的返回值。

public class CallableFutrueTest {
    public static void main(String[] args) {
        CallableTest ct = new CallableTest();                        //创建对象
        FutureTask<Integer> ft = new FutureTask<Integer>(ct);        //使用FutureTask包装CallableTest对象
        for(int i = 0; i < 100; i++){
            //输出主线程
            System.out.println(Thread.currentThread().getName() + "主线程的i为：" + i);
            //当主线程执行第30次之后开启子线程
            if(i == 30){
                Thread td = new Thread(ft,"子线程");
                td.start();
            }
        }
        //获取并输出子线程call()方法的返回值
        try {
            System.out.println("子线程的返回值为" + ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class CallableTest implements Callable<Integer>{
    //复写call() 方法，call()方法具有返回值
    public Integer call() throws Exception {
        int i = 0;
        for( ; i<100; i++){
            System.out.println(Thread.currentThread().getName() + "的变量值为：" + i);
        }
        return i;
    }
}

4、使用线程池创建：

public class ThreadTest {
 
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(50);
    
    public void dothing(){
        for(int i=0;i<50;i++){
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //do something
                }
            });
        }
        fixedThreadPool.shutdown();//关闭线程池
 
        //此处不可以删除或注释，需要线程执行结束后再执行别的内容,即只有线程结束后才会继续向下执行
        while (!fixedThreadPool.isTerminated()) {
 
        }
    }
}

线程池的特点：
1.通过复用已存在的线程，降低线程创建和消耗带来的损耗。
2.提高相应速度，通过复用已存在的新线程，无序等待便能立即执行
3.提供更强大的功能：延时定时线程池

1.可缓存线程池 Executors.newCacheThreadPool()：先查看池中有没有线程。如果有直接使用，没有则新建。（通常适用于执行一些生存期很短的线程）
线程池为无限大，当执行完上一个任务后，后面的任务会复用上一个任务的线程，而不用每次新建。

2.定长线程池Executors.newFixedThreadPool(int n)：创建一个固定长度的线程池，以共享的无界队列方式来运行这些线程。

3.延时定时线程池Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持延时和定时。

4.单线程化的线程池Executors.newSingleThreadExecutor()：它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

线程安全和线程锁

1、线程安全
既然提到了线程安全，我们就知道有的线程肯定是不安全的，那么来举两个例子，有如下代码：

Integer count = 0;
public void getCount() {
       count ++;
       System.out.println(count);
 }

当我们开启线程并且每个线程访问10次时，有如下结果：
在这里插入图片描述
这里出现了两个重复数字，可以看出这个线程并不是安全的，其中最常见的问题就是A线程进入后读取count还没开始加一时，线程B进来了，这样导致两个线程拿到的值时一样的。

再看下面这段代码：

public void threadMethod(int i) {
    i = i + 1;
}

这段代码很容易看出来，这个方法只对传入的参数进行操作，对别的线程参数没有不会有任何影响，所以说它时绝对安全的。

所以可以总结一下：当多个线程访问某个方法时，不管你通过怎样的调用方式、或者说这些线程如何交替地执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。

2、线程锁
既然存在线程安全的问题，那么肯定得想办法解决这个问题，怎么解决？我们说说常见的几种方式

synchronized关键字
关键字synchronized的作用是实现线程间的同步。它的工作是对同步的代码加锁,使得每一次,只能有一个线程进入同步块,从而保证线程间的安全性。

关键字synchronized可以有多张用法,这里做一个简单的整理:

指定加锁对象:对给定对象加锁,进入同步代码前要获取给定对象的锁。
直接作用于实例方法:相当于给当前实例加锁,进入同步代码块前要获得当前实例的锁。
直接作用于静态方法:相当于对当前类加锁,进入同步代码前要获取当前类的锁。

下面来分别说一下上面的三点:
假设我们有下面这样一个Runnable,在run方法里对静态成员变量sCount自增10000次:

class Count implements Runnable {
    private static int sCount = 0;

    public static int getCount() {
        return sCount;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            sCount++;
        }
    }
}

假设我们在两个Thread里面同时跑这个Runnable:

Count count = new Count();
Thread t1 = new Thread(count);
Thread t2 = new Thread(count);
t1.start();
t2.start();
try {
    t1.join();
    t2.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.print(Count.getCount());

得到的结果并不是20000,而是一个比20000小的数,如14233。

这是为什么呢？假设两个线程分别读取sCount为0,然后各自技术得到sCount为1,并先后写入这个结果,因此,虽然sCount++执行了2次,但是实际sCount的值只增加了1。

我们可以用指定加锁对象的方法解决这个问题,这里因为两个Thread跑的是同一个Count实例,所以可以直接给this加锁:

class Count implements Runnable {
    private static int sCount = 0;

    public static int getCount() {
        return sCount;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            synchronized (this) {
                sCount++;
            }
        }
    }
}

synchronized直接作用于静态方法的用法和上面的给实例方法加锁类似,不过它是作用于静态方法:

class Count implements Runnable {
    private static int sCount = 0;

    public static int getCount() {
        return sCount;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            increase();
        }
    }

    private static synchronized void increase() {
        sCount++;
    }
}

lock
先来说说它跟synchronized有什么区别吧，Lock是在Java1.6被引入进来的，Lock的引入让锁有了可操作性，什么意思？就是我们在需要的时候去手动的获取锁和释放锁，甚至我们还可以中断获取以及超时获取的同步特性，但是从使用上说Lock明显没有synchronized使用起来方便快捷。我们先来看下一般是如何使用的：

private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子类

   private void method(Thread thread){
       lock.lock(); // 获取锁对象
       try {
           System.out.println("线程名："+thread.getName() + "获得了锁");
           // Thread.sleep(2000);
       }catch(Exception e){
           e.printStackTrace();
       } finally {
           System.out.println("线程名："+thread.getName() + "释放了锁");
           lock.unlock(); // 释放锁对象
       }
   }

进入方法我们首先要获取到锁，然后去执行我们业务代码，这里跟synchronized不同的是，Lock获取的所对象需要我们亲自去进行释放，为了防止我们代码出现异常，所以我们的释放锁操作放在finally中，因为finally中的代码无论如何都是会执行的。

写个主方法，开启两个线程测试一下我们的程序是否正常：

public static void main(String[] args) {
       LockTest lockTest = new LockTest();

       // 线程1
       Thread t1 = new Thread(new Runnable() {

           @Override
           public void run() {
               // Thread.currentThread()  返回当前线程的引用
               lockTest.method(Thread.currentThread());
           }
       }, "t1");

       // 线程2
       Thread t2 = new Thread(new Runnable() {

           @Override
           public void run() {
               lockTest.method(Thread.currentThread());
           }
       }, "t2");

       t1.start();
       t2.start();
   }

结果：
在这里插入图片描述
可以看出我们的执行，是没有任何问题的。
还有其他很多锁就不一一列举，详细介绍可以看下面这篇博客：https://www.jianshu.com/p/fa084227c96b

吃饭睡觉改bug

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
多线程相关知识详解！

多线程相关知识详解进程和线程是什么？线程的生命周期创建线程的多种方式线程安全和线程锁进程和线程是什么？进程：在我们的电脑上有很多单独运行的程序，这每一个程序都有一个独立的进程，进程之间相互独立，比如我们电脑上的qq，微信，电脑管家等。线程：进程想执行任务就需要依赖线程，一个进程中至少有一个线程。那么什么是多线程呢？先来了解一下串行和并行。串行：就是一个线程执行执行多条任务时，必须先执行完A，然后再执行B，最后执行C。并行：比如在下载多个文件时开启多条线程，多个文件同时进行下载，这里是严格
复制链接

扫一扫