线程回顾

最新推荐文章于 2021-08-07 01:05:40 发布

雷玉荣

最新推荐文章于 2021-08-07 01:05:40 发布

阅读量202

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_21098263/article/details/104960045

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

进程定义

 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 [1]
    理解：进程是操作系统中的一个任务（一个应用，比如QQ，就是一个QQ进程）（）

进程的特征

动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
并发性：任何进程都可以同其他进程一起并发执行
独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；
异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进
结构特征：进程由程序、数据和进程控制块三部分组成。
多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

线程

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之    中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程  中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被   称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel  thread），而把用户线程（user thread）称为线程。
 线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。
同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。
一个进程可以有很多线程，每条线程并行执行不同的任务。
在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率

 线程：线程是操作系统中执行任务的最小单元，一个线程和自己所属的进程共享系统资源

进程与线程的区别

     进程由多个线程组成共同完成任务，多个线程可以共享进程的系统资源，但是进程的有一部分私有资源只能是由进程访问，线程是不能够使用的。

创建线程的4种方式

第一种方式
可以继承Thread类重写run方法，将需要实现的代码包装在run方法里面，当启动线程的时候，该线程获取到CPU处理器运行的时间片段，那么run方法里面的程序就会得到执行。
第二种方式：
可以直接实现Runable接口重写run方法
第三种方式：
采用匿名内部类创建线程
使用Callable方式创建线程，主要是实现Callable接口的call方法，该方法拥有返回值，线程执行完毕之后可以拿到该返回值。而前面的3种没有返回值
使用第四种方式创建线程的时候，不能直接将Callable类型的对象作为种子（target）放入Thead类的构造器中，应该借助于FutureTask类，该类实现Runable接口，这时候就可以将FutureTask类型的对象放入Thread的构造器，通过Thead提供的start方法开启线程去执行Callable接口里面的run方法。这个方法有一个V（类型的返回值），可以通过FutureTask接口提供的get方法获取call方法运行完毕之后的返回值。
FutureTask的类继承关系如下：

线程的相关状态

在这里插入图片描述

线程相关API

getCurrentThread获取当前线程

getId获取当前线程ID

getName获取线程名称

isAlive判断线程是否存活如果是返回true,否则返回Fasle

getState获取线程的状态

getPriority 获取线程的优先级

isdiamon 判断线程是否是守护线程（后台线程）

yield 方法让当前运行的线程让出处理器资源回到ready状态

stop方法强行停止线程（不建议）

sleep方法让当前线程睡眠指定的时间

interupt 让当前线程正常结束运行之后停止

isinterupted 判断当前线程是否已经被打断

 //获取当前线程
        System.out.println(Thread.currentThread());
        //获取当前线程名称
        System.out.println(Thread.currentThread().getName());
        //获取当前线程ID
        System.out.println(Thread.currentThread().getId());
        //获取当前线程的状态
        System.out.println(Thread.currentThread().getState());
        //获取当前线程的优先级
        System.out.println(Thread.currentThread().getPriority());
        //判断当前线程是否死亡
        System.out.println(Thread.currentThread().isAlive());
        //判断当前线程是否是守护线程（后台线程）
        System.out.println(Thread.currentThread().isDaemon());
        Thread.currentThread().interrupt();
        System.out.println(Thread.currentThread().isInterrupted());
      
        /**
         * 调用 interrupt方法后，不是马上中断线程，而是发出一个中断信号，
         * 当当前线程的所有的任务执行完毕之后，线程才会被终止
         */
        Thread.currentThread().interrupt();
        System.out.println(Thread.currentThread().isInterrupted());
        System.out.println("*********");

线程安全

多线程可能会引发线程安全问题，主要是多个线程共享同一份 资源的时候可能会出现线程安全问题。
比如抢红包：8个人抢8个红包，最后的结果应该是所有人抢的钱应该加起来等于发红包的金额，最后一个红包抢后最后的余额应该是0；
如何解决线程安全问题：
       第一种方式：把所有业务都使用一个单线程实现（分布式环境下是不允许的）
       第二种方式：锁机制
           锁机制分为：重量级锁和轻量级锁（无锁机制）
              重量级锁：   synchronize锁  可重入锁
              轻量级锁：  cas锁  swap等

synchronized锁的使用

sychronized锁属于重量级锁，所对象一般是this;synchronized锁也可以叫做监视器（同步监视器），在多线程环境下，如果多个线程共享同一份 资源的时候，可以使用synchronized锁解决线程安全问题。
这样先执行该方法的线程就可以优先获取到同步监视器（锁），等到方法执行完毕之后，该线程会自动释放锁。其他线程才可以进入该方法继续执行。
 synchronize可以在方法之上使用，表示为该方法进行加锁，也可以在方法里面使用，这种方式就是
 同步代码块：
    格式是：  synchronized(所对象){

       }
       使用同步锁代码块可以缩小锁的粒度，这样能够使得处理器资源得到最大化的利用。

package com.sx.repeat.thread.red;


public class Beans {
    /**
     * 50颗豆子
     * 多个人去抢，等到抢完以后，要求不能再抢
     */
    private int totalBean = 50;

    public    int distribute(){
        System.out.println("抢豆子游戏");
        System.out.println(Thread.currentThread().getName() + "抢到了");
        synchronized (this) {
            System.out.println("剩余豆子：" + (--totalBean));
            if (totalBean <= 0) {
                System.out.println("没有豆子了");
                System.exit(0);  //强制退出虚拟机
            }

        }
        System.out.println("本次抢豆子完毕");
        return totalBean;

    }
}


package com.sx.repeat.thread.red;


import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Driver00 {

    public static void main(String[] args) {
        Beans beans = new Beans();
        Callable<Integer> c1=()->{
            for (int i = 0; i <100 ; i++) {
                beans.distribute();
            }
           return  0;
        };
        Callable<Integer> c2=()->{
            for (int i = 0; i <100 ; i++) {
                beans.distribute();
            }
            return  0;
        };
    Callable<Integer> c3=()->{
        for (int i = 0; i <100 ; i++) {
            beans.distribute();
        }
        return  0;
    };
        Callable<Integer> c4=()->{
            for (int i = 0; i <100 ; i++) {
                beans.distribute();
            }
            return  0;
        };
        FutureTask<Integer> task1 = new FutureTask<>(c1);
        FutureTask<Integer> task2 = new FutureTask<>(c2);
        FutureTask<Integer> task3 = new FutureTask<>(c3);
        FutureTask<Integer> task4 = new FutureTask<>(c4);
        //开启三个线程去强豆子
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        Thread t3 = new Thread(task3);
        Thread t4 = new Thread(task4);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

可重入锁：

 ReteenLocak   
    该类提供了一个lock方法对当前的对象加锁
    方法运行完毕之后一定要手动释放锁 unlock方法

package com.sx.repeat.thread.red;


import java.util.concurrent.locks.ReentrantLock;

public class Beans {
    /**
     * 50颗豆子
     * 多个人去抢，等到抢完以后，要求不能再抢
     */
    private int totalBean = 50;
    private final ReentrantLock reentrantLock = new ReentrantLock();
    public    int distribute(){
        System.out.println("抢豆子游戏");
        System.out.println(Thread.currentThread().getName() + "抢到了");
         reentrantLock.lock();  //加锁
            System.out.println("剩余豆子：" + (--totalBean));
            if (totalBean <= 0) {
                System.out.println("没有豆子了");
                System.exit(0);  //强制退出虚拟机
            }

          reentrantLock.unlock();//释放锁
        System.out.println("本次抢豆子完毕");
        return totalBean;

    }
}

线程通信

   多线程环境下多个线程之间可能需要进行通信，如果方法上面使用synchronized锁机制对方法进行加锁，那么线程之间的通信可以使用Object类提供的Wait  和notefy,notefyAall进行通信
   wait表示当前线程等待，notefy表示唤醒一个线程（如果有多个线程在等待的时候，那么随机唤醒其中一个线程），notefyAll表示唤醒多个线程。

package com.sx.repeat.thread.download;

/**
 * @phone:13595672347
 * @qq:1441826270
 * @作者：雷玉荣
 * @company: 贵州达内科技有限公司
 * @program 程序 = 数据结构 + 算法 (构成元素 + 运行机理)
 * @comment 达内教育专注于做技术人的指路明灯，
 * 职场生涯的精神导师
 * @date 2020/3/19 16:19
 */
public class Pic {
    //判断图片下载是否完毕
    private boolean flag = false;
    public synchronized void donwload()  {
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("当前图片下载："+i+"%");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag = true;
        notify();  //通知显示图片的线程
    }

    public synchronized  void display()  {
        if(!flag){  //图片没有下载完毕  等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("当前图片显示："+i+"%");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package com.sx.repeat.thread.download;

public class Driver {

    public static void main(String[] args) {

        Pic pic = new Pic();

        Runnable r1 = ()->{
            pic.donwload();
        };

        Runnable r2 = ()->{
            pic.display();
        };
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t2.start();
        t1.start();

    }
}

如果方法使用synchronized加锁，那么线程之间的通信可以使用Object提供的wait和notfy方式进行通信；否则必须使用Condition通信，使用Condition类提供signal方法唤醒一个线程，使用 condition.signalAll();方法唤醒所有的线程，await方法就是让当前线程等待知道收到signal信号。

package com.sx.repeat.thread.download;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @phone:13595672347
 * @qq:1441826270
 * @作者：雷玉荣
 
 * @date 2020/3/19 16:19
 */
public class Pic001 {
    private final ReentrantLock reentrantLock = new ReentrantLock();
    //判断图片下载是否完毕
    private boolean flag = false;
    private Condition condition = reentrantLock.newCondition();
    public void donwload()  {
        reentrantLock.lock();
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("当前图片下载："+i+"%");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag = true;
        //通知另外的线程可以下载图片了
        condition.signal();  //发出信号
       
        reentrantLock.unlock();
    }

    public  void display()  {
        reentrantLock.lock();
        if(!flag) {  //图片没有下载完毕  等待
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("当前图片显示："+i+"%");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        reentrantLock.unlock();
    }
}

线程池

线程组

缓冲队列实现线程安全

java.util.concurent包

线程类 ThreadLocal

Java的反射技术

Java的注解开发

雷玉荣

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
线程回顾

进程定义进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 [1] 理解：进程是操作系统中的一个任务（一个应用，比如QQ，就是一个QQ进程）（）...
复制链接

扫一扫