栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

一文看懂Java多线程和并发

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

一文看懂Java多线程和并发

Java多线程

背景
单线程只使用一个CPU完成多个任务(调用多个方法),肯定比用多个线程完成的总时间更短,为什么要使用多线程呢?
答:1.提高应用程序的响应,增强用户体验;2.提高计算机系统CPU的利用率。

1. 基础知识补充

进程,线程;并发,并行的概念:

进程:程序的一次执行过程,是一个动态的过程。进程作为资源分配的最小单位,一个进程至少拥有一个线程;
线程:线程堆空间是共享的,栈空间相互独立。线程是CPU调度的最小单位 ;
并发:一个CPU同时执行多个任务;
并行:多个CPU同时执行多个任务;
进程运行过程中的三种基本状态:(a)就绪状态(Ready),(b)运行状态(Running),(c)阻塞状态(Blocked)。


代码层面的状态Thread.State

2. 线程创建的三种方式

方式一:继承Thread类
方式二:实现Runnable接口
方式三:JDK1.5新增:实现Callable接口

结合代码分析三种线程创建的优缺点:

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

//线程创建的三种方式

public class ThreadTest {
    public static void main(String[] args) {
        //------------------------方式1-----------------------------------------
        //new一个新线程对象
        MyThread myThread = new MyThread();
        //调用start方法启动线程,(执行的还是run方法)
        myThread.start();
        
        //------------------------方式1-----------------------------------------


        //------------------------方式2-----------------------------------------
                //------------------方式2------------第1种-----------
        Runnable target = new MyRunnable();
        Thread t = new Thread(target);
        t.start();
                //------------------方式2------------第2种------------
        Runnable t2 = new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 4; i++){
                    System.out.println("子线程3输出:" + i);
                }

            }
        };
        Thread thread = new Thread(t2);
        thread.start();
        //------------------------方式2-----------------------------------------

        //------------------------方式3-----------------------------------------
        //创建Callable对象
        Callable call = new MyCallable(12);
        //把Callable对象交给FutureTask对象
            
        FutureTask f1 = new FutureTask<>(call);
        //交给线程处理
        Thread t4 = new Thread(f1);
        t4.start();

        //通过get方法得到线程对象结果
        try {
            System.out.println(f1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //------------------------方式3-----------------------------------------

        for(int i = 0; i < 4; i++){
            System.out.println("主线程输出:" + i);
        }
    }
}


class MyThread extends Thread{
    @Override       //重写run方法
    public void run() {
        super.run();
        for(int i = 0; i < 4; i++){
            System.out.println("子线程1输出:" + i);
        }
    }
}


class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 4; i++){
            System.out.println("子线程2输出:" + i);
        }
    }
}


class MyCallable implements Callable{
    private int n;
    public MyCallable(int n ){
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for(int i = 1; i < n; i++){
            sum += i;
        }
        return "子线程执行结果是:" + sum;
    }
}
3. 线程同步

线程同步是为了解决什么问题?
在多线程操作中,多个线程可能同时处理同一个资源,特别是对统一资源进行修改的时候,就容易出现线程安全问题。
线程同步解决线程安全的思想:对共享资源进行加锁。

3.1 同步代码块

作用:把出现线程安全问题的核心代码给上锁。
原理:每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行。

        synchronized (同步锁对象){
            操作共享资源的代码(核心代码)
        }
        锁对象的规范要求:
        	建议使用共享资源作为锁对象;
        	对于实例方法建议使用this作为锁对象;
        	对于静态方法建议使用字节码(类名.class)对象作为锁对象;
3.2 同步方法

作用:把出现线程安全问题的核心方法给上锁。原理同上。

       修饰符 synchronized 返回值类型(形参列表){
            操作共享资源的代码(核心代码)
        }	

关于synchronized的知识补充:

synchronized在同步代码块中是通过明确的monitorenter和monitorexit指令实现;
synchronized在同步方法中是通过ACC_SYNCHRONIZED标志来隐式实现。

Java早期版本中,synchronized属于重量级锁,因为挂起或者唤醒一个线程,都需要操作系统帮忙完成,而操作系统实现线程之间的切换时需要从用户态转换成内核态,这个转换花费时间比较长,这也是早期synchronized效率低的原因;
JDK1.6之后,synchronized关键字底层的优化,出现了自旋锁、偏向锁、轻量级锁等技术来减少锁操作的开销。

锁的四种状态:无锁——》偏向锁——》轻量级锁——》重量级锁,注意锁升级的过程是不可逆的。
偏向锁:总是由同一个线程多次获取,那么此时就是偏向锁;
轻量级锁:轻量级锁由偏向锁升级而来,当存在第二个线程申请同一个锁对象时,偏向锁就会立即升级为轻量级锁。注意这里第二个线程只是申请锁,不存在两个线程同时竞争锁,可以是一前一后地交替执行同步块;
重量级锁:由轻量级锁升级而来,当同一时间,有多个线程申请同一个锁对象,轻量级锁就会被升级为重量级锁;

CAS:compare and swap,又称为无锁或者自旋锁。
大概意思是当你获取当前数值为1,最后输出和1比较,相同就不用加锁。
ABA问题:线程a把1改成3,线程2有把3改回成1,最终a还是1,但是在第一步中a等于3;

如何在项目中使用synchronized
synchronized关键字主要的三种使用方式:
1、修饰实例方法:作用于当前对象实例加锁,进入同步代码前要获得当前对象实例的锁;
2、修饰静态方法:作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁。当一个线程A调用实例对象的非静态synchronized方法,而线程B调用这个实例对象所属类的静态synchronized方法,是允许的,不会发生互斥现象,因为访问静态synchronized方法占用的锁是当前类的锁,而访问非静态synchronized方法占用的锁是当前实例对象的锁;
3、修饰代码块:指定加锁对象,对给定对象加锁,进入同步代码块前要获得给定对象的锁。synchronized(this){代码块} 也是锁定当前对象。synchronized关键字加到static静态方法和synchronized(class)代码块上都是给Class类上锁。

class Test1{

    private int i = 0;
    private static int j = 0;
    private final SynchronizedTest aa = new SynchronizedTest();

    //修饰实例方法: 锁对当前对象(this)  flags:  ACC_PUBLIC,ACC_SYNCHRONIZED
    public synchronized void add1(){
        i++;
    }

    //对静态方法加锁: 锁对当前类的字节码文件(Test1.class)    静态方法属于类,不属于对象。  flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    public synchronized static  void add2(){
        j++;
    }

    //修饰代码块,指定加锁对象      flags: ACC_PUBLIC;  monitorenter monitorexit
    public void method(){
        synchronized (Test1.class){
            System.out.println("11");
        }
        synchronized (aa){
            System.out.println("22");
        }
    }
}

可以通过在终端输入指令javap -p -v -v Test1.class查看到,同步代码块基于monitorenter、monitorexit实现,而同步方法基于ACC_SYNCHRONIZED标识实现。

3.2 同步锁
// final修饰后,锁对象是唯一和不可替换的。
final Lock lock = new ReentrantLock();
lock.lock();	//上锁
try{
	}finally{
	lock.unlock();	//解锁
}
4. 线程的死锁

死锁的解释:
当不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续。

生产者消费者案例代码(解决死锁的一个案例):

https://blog.csdn.net/qq_41894176/article/details/123829040

4. 线程池

什么是线程池?为什么要使用线程池?

1、线程池就是一个可以复用线程的技术。
2、如果用户没发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能。

谁代表线程池?

JDK1.5起提供代表线程池的接口:ExecutorService

怎么得到线程池对象?

方式一:使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池对象;
方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象;

ThreadPoolExecutor构造器的参数说明:

临时线程什么时候创建?

新任务提交是发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程。

什么时候开始拒绝任务?

核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝。

使用ThreadPoolExecutor线程池处理Runnable和Callable

import java.util.concurrent.*;

public class ThreadPoolTest {
    public static void main(String[] args){
        //1.创建线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//
//        //-----------------------------Runnable--------------------------
//        //2.将任务交给线程池处理
//        Runnable target = new RunnableMy();
//        pool.execute(target);
//        pool.execute(target);
//        pool.execute(target);
//
//        //5
//        pool.execute(target);
//        pool.execute(target);
//        pool.execute(target);
//        pool.execute(target);
//        pool.execute(target);
//
//        //创建临时线程            [当等待线程超过5个时,就会创建临时线程] new ArrayBlockingQueue<>(5)
//        pool.execute(target);
//        pool.execute(target);
//
//        //当线程数超过5个时,会报错
//        pool.execute(target);
//
//        //关闭线程池(一般不会使用)
        pool.shutdown();    //立即关闭,即使任务没有完成,会丢失任务!!
//        //-----------------------------Runnable--------------------------

        //-----------------------------Collable--------------------------
        Future f1 = pool.submit(new CallableMy(10));
        Future f2 = pool.submit(new CallableMy(5));
        Future f3 = pool.submit(new CallableMy(100));

        try {
            System.out.println(f1.get());
            System.out.println(f2.get());
            System.out.println(f3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //-----------------------------Collable--------------------------

    }
}
class RunnableMy implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 3; i++){
            System.out.println("Runnable:" + i +  "____" + Thread.currentThread().getName());
        }
        try {
            System.out.println("线程进入休眠--->" + Thread.currentThread().getName());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class CallableMy implements Callable{
    private int n;
    public CallableMy(int n ){
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for(int i = 1; i < n; i++){
            sum += i;
        }
        System.out.println(Thread.currentThread().getName() + ":" + "Callable");
        return "子线程执行结果是:" + sum;
    }
}

——————————————————

未完待续
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/961857.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号