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

Java并发编程

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

Java并发编程

目录

创建线程的方式:

1,继承Thread

2,Runnable()

//实现runnable接口重写run方法,实现Runnable接口的实现类的实例对象作

3,Callable()

守护线程

线程安全问题:

        1 :synchronized(悲观锁)

        2:lock加锁,unlock解锁

        3:volatile

        4:CAS(乐观锁)

       5:Threadlocal 

 会造成内存泄漏: map是线程持有的,生命周期随线程 ,如果线程没有remove,entry就会在。

如何避免泄漏

为了防止此类情况的出现,我们有两种手段。

ReentrantLock:

饥饿及解决办法

面试常见问题:

1   停止线程的方式?

2 线程池,线程池参数?

创建线程池的方式:

一 , 通过Executors接口

二 ,ThreadPoolExecutor

三 forkjoin线程池

线程池执行流程:

3  为什么CAS比synchronized效率高?


JMM(java内存模型)

  java内存模型是一套在多线程读写共享数据时,对共享数据的可见性,有序性,原子性的规则和保障。

并发编程的三个问题 可见性

 

原子性

 

有序性 

 

创建线程的方式:

1,继承Thread

                                t = new Thread(){

                                        public void run(){//匿名内部类,而不用自己写子类继承Thread类

                                

                                         }

                                   }

                                t.start()//就绪状态,具体执行由os调度器决定什么时候执行

2,Runnable()

//实现runnable接口重写run方法,实现Runnable接口的实现类的实例对象作

r = new Runnable(){//任务对象

        public void run(){

}

}

                        new Thread(r).start();

1,2方法的区别,两者都是调用了Thread的run方法

3,Callable()

//执行Callable 方式,需要FutureTask 实现,用于接收运算结果
        FutureTask futureTask = new FutureTask(new MyCallable());
        new Thread(futureTask).start();
        //接收线程运算后的结果
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
 
class MyCallable implements Callable {
 
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}
 Thread.wait()方法会占用锁  不会释放 但是会让出cpu使用权

join()方法会等 线程执行完毕,join的底层就是wait

interrupt()方法是打断线程,不管是正常运行的线程还是正在sleep,wait,join的线程

守护线程

:正常情况下,只要有线程还在运行,进程就不会停止,但是设置线程为守护线程之后 ,其他非守护线程都停止了,该守护线程也就停止了。守护线程守护的是进程。

gc线程就是守护线程。

线程安全问题:

        1 :synchronized(悲观锁)

        对象头:

|--------------------------------------------------------------|
|                     Object Header (64 bits)                  |
|------------------------------------|-------------------------|
|        Mark Word (32 bits)         |    Klass Word (32 bits) |
|------------------------------------|-------------------------|

下面是对象头里的Mark Word

轻量级锁:如果一个对象,多个线程访问,但是多线程访问时间都是错开的,没有竞争,那么就使用轻量级锁来优化。

 1.让锁记录中Object reference指向锁对象,并尝试用cas替换Object的mark word,将markword的值存入锁记录。2 如果cas替换成功,对象头中存储的是锁记录地址和状态00 表示由该线程给对象加锁。3 如果cas失败,有两种情况: 如果是其他线程已经持有该Object的轻量级锁,这表明有竞争,进入锁膨胀过程。如果是自己执行了重入,那么再添加一条Lock Record作为重入的计数。

锁膨胀:如果在尝试加轻量级锁的过程中,cas失败,进入锁膨胀,将轻量级锁变为重量级锁。

即为Object申请monitor锁,让object指向重量级锁。然后自己进入monitor的EntryList blocked

当之前占用轻量级锁的线程退出解锁时,使用cas恢复对象头失败,这时会进入重量级锁的解锁流程,按照monitor地址找到monitor对象,设置owner为null 唤醒EntryList中的blocked线程。

默认开启偏向锁,那么对象创建后,markword最后三位是101,偏向锁默认是延迟的,不会在程序启动时立即生效,如果想避免延迟,可以加vm参数-xx:BiasedLockingStartupDelay=0来禁止延迟。

        2:lock加锁,unlock解锁

        3:volatile

 

                修饰共享变量,保持对共享变量的可见性,禁止指令重排序,但是不保证原子性。

 

volatile关键字会开启总线得mesi缓存一致性协议。

mesi缓存一致性协议:多个CPU从主内存读取同一个数据到各自得高速缓存,当其中某个cpu修改了缓存里得数据,该数据会马上同步回主内存,其他cpu通过总线嗅探机制可以感知到数据得变化从而将自己缓存里得数据失效

        4:CAS(乐观锁)

                不断尝试 主存的最新值和工作内存的值是否相等,如果相等则把修改后的值写入主存,如果不相等 ,不断尝试循环判断。直到相等为止。所以他也是乐观锁的一种实现方式。

       5:Threadlocal 

        ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射,各个线程之间的变量互不干扰,在高并发场景下,可以实现无状态的调用,特别适用于各个线程依赖不通的变量值完成操作的场景。

 会造成内存泄漏: ThreadLocal的key在源码中被设置为弱引用 
   static class Entry extends WeakReference> {
            
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

因为一般ThreadLocal对象都是声明在静态变量,使用gc时不会被回收,也就不会key为null,也就不会触发a) b).因此使用完手动remove map是线程持有的,生命周期随线程 ,如果线程没有remove,entry就会在。

不管ThreadLocalMap的key是弱引用还是强引用,Value是强引用 。这就导致了一个问题,内存泄漏。如果key是强引用 ,key,value都不会gc,也就会造成内存泄漏。如果key是弱引用,ThreadLocal在没有外部对象强引用时,发生GC时弱引用Key会被回收,而Value不会回收。下一轮value会被置为null。(而不是因为key是弱引用,造成内存泄漏。)

如何避免泄漏

为了防止此类情况的出现,我们有两种手段。

1、使用完线程共享变量后,显示调用ThreadLocalMap.remove方法清除线程共享变量;
既然Key是弱引用,那么我们要做的事,就是在调用ThreadLocal的get()、set()方法时完成后再调用remove方法,将Entry节点和Map的引用关系移除,这样整个Entry对象在GC Roots分析后就变成不可达了,下次GC的时候就可以被回收。

2、JDK建议ThreadLocal定义为private static,这样ThreadLocal的弱引用问题则不存在了。 


一、什么是AQS
AQS,在java.util.concurrent.locks包中,AbstractQueuedSynchronizer这个类是并发包中的核心,了解其他类之前,需要先弄清楚AQS。

AQS就是一个同步器,要做的事情就相当于一个锁,所以就会有两个动作:一个是获取,一个是释放。获取释放的时候该有一个东西来记住他是被用还是没被用,这个东西就是一个状态。如果锁被获取了,也就是被用了,还有很多其他的要来获取锁,总不能给全部拒绝了,这时候就需要他们排队,这里就需要一个队列。

AQS的核心思想是:通过一个volatile修饰的int属性state代表同步状态,例如0是无锁状态,1是上锁状态。多线程竞争资源时,通过CAS的方式来修改state,例如从0修改为1,修改成功的线程即为资源竞争成功的线程,将其设为exclusiveOwnerThread,也称【工作线程】,资源竞争失败的线程会被放入一个FIFO的队列中并挂起休眠,当exclusiveOwnerThread线程释放资源后,会从队列中唤醒线程继续工作,循环往复。


ReentrantLock:
reentrantLock.lock();//获取锁
try{
    //执行的被保护的代码
}finally{
reentrantLock.unlock();//释放锁

}

介绍可重入锁的概念(synchronized和ReentrantLock 都是可重入锁) 

  private static ReentrantLock lock=new ReentrantLock();
    public static void main(String[] args) {
        lock.lock();
        try{
            System.out.println("enter main");
            m1();
        }finally {
            lock.unlock();
        }
    }

    private static void m1() {
        lock.lock();
        try{
            System.out.println("enter m1");
            m2();
        }finally {
            lock.unlock();
        }
    }

    private static void m2() {
        lock.lock();
        try{
            System.out.println("enter m2");
        }finally {
            lock.unlock();
        }
    }

同一个锁被同一线程中不同的方法可以重复获取(同一线程多次获取同一把锁)就叫做可重入锁。 

相比synchronized的优点:一个是jvm层面的,一个是jdk层面的。1)可中断 (可中断正在等待的线程)

                                

     Thread t1 = new Thread(() -> {
            try {
                System.out.println("t1正在尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("没有获取到锁,返回");
                return;
            }
            try{
                System.out.println("获取到锁");

            }finally {
                lock.unlock();
            }

        }, "t1");
        lock.lock();
      t1.start();
      sleep(1);
        System.out.println("打断t1");
      t1.interrupt();

打断的意思是打断,因为锁被别的线程占用的阻塞线程。不让阻塞线程去获取锁了,因此 也是避免死锁的一种方式。 但是因为是由其他线程 来打断的,是被动结束死等的。

 2)可设置超时时间(如果在一段时间内,没有获取锁,则放弃等待,获取锁失败了。避免死锁,相对中断,是主动结束死等状态的)

  Thread t1 = new Thread(() -> {
            System.out.println("t1正在尝试获取锁");
            boolean b = false;
            try {
                b = lock.tryLock(2, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(!b){
                System.out.println("获取不到锁");
                return;
            }
            try{
                System.out.println("获取到锁");

            }finally {
                lock.unlock();
            }

        }, "t1");
        lock.lock();
      t1.start();
      sleep(1);
      lock.unlock();
       // System.out.println("打断t1");
      //t1.interrupt();

3)可以设置公平锁(ReentrantLock和synchronized默认是不公平锁,但是ReentrantLock可以通过构造方法设置为公平锁)

公平锁的本意是用来解决饥饿问题的,一般不用,会降低并发度。

死锁:两个或多个进程都处于互等状态而无法继续工作

解决办法:

顺序加锁 

饥饿及解决办法

解决办法:

tryLock()

公平锁(不推荐 因为会降低并发度)


面试常见问题:

1   停止线程的方式?

1)this.interrupt()+this.isInterrupted()+return

//创建一个demo线程类
public class Demo extends Thread {
	
	public Demo() {
		
	}
	@Override
	public void run() {
		super.run();
		
		for(int i = 0;i<50000;++i)
		{
			if(this.isInterrupted())
			{
				System.out.println("demo线程终止了");
				return;
			}
			System.out.println(i);
		}
	}
}

//测试
public class Test {

	public static void main(String[] args) throws Exception {
		
		Demo demo = new Demo();
		demo.start();
		Thread.sleep(50);
		demo.interrupt();
		Thread.sleep(50);			
	}
}

2)this.interrupt()+this.isInterrupted()+异常

3)sleep()+this.interrupt()+异常

public class Demo extends Thread {
	
	public Demo() {
		
	}
	@Override
	public void run() {
		super.run();
		
		try {
			Thread.currentThread().sleep(2000);
		} catch (InterruptedException e) {
			
			System.out.println("抛出异常,线程终止了");
		}
	}

}

public class Test {

	public static void main(String[] args) throws Exception {
		
		Demo demo = new Demo();
		demo.start();
		demo.interrupt();
		
				
	}
}
	

2 线程池,线程池参数?

创建线程池的方式:

一 , 通过Executors接口

 Executors.newFixedThreadPool:创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待;
Executors.newCachedThreadPool:创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程;
Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执行顺序;
Executors.newScheduledThreadPool:创建一个可以执行延迟任务的线程池;
Executors.newSingleThreadScheduledExecutor:创建一个单线程的可以执行延迟任务的线程池;
Executors.newWorkStealingPool:创建一个抢占式执行的线程池(任务执行顺序不确定)【JDK 1.8 添加】。

二 ,ThreadPoolExecutor


ThreadPoolExecutor:最原始的创建线程池的方式,它包含了 7 个参数可供设置

三 forkjoin线程池

ForkJoinPool : 专门用来运行 ForkJoinTask 的线程池,(在实际使用中,也可以接收Runnable/Callable 任务,但在真正运行时,也会把这些任务封装成 ForkJoinTask 类型的任务)。
ForkJoinTask : 基本任务,使用fork、join框架必须创建的对象,提供fork,join操作,常用的三个子类如下:

RecursiveAction

无结果返回的任务

RecursiveTask

有返回结果的任务

CountedCompleter

无返回值任务,完成任务后可以触发回调

线程池七大参数:

 public ThreadPoolExecutor(int corePoolSize,//核心线程数,线程池中始终存活的线程数。
                           int maximumPoolSize,//最大线程数,线程池中允许的最大线程数,当线程池的任务队列满了之后可以创建的最大线程数
                           long keepAliveTime,//最大线程数可以存活的时间,当线程中没有任务执行时,最大线程就会销毁一部分,最终保持核心线程数量的线程
                           TimeUnit unit,
                           BlockingQueue workQueue,//一个阻塞队列,用来存储线程池等待执行的任务,均为线程安全..较常用的是 LinkedBlockingQueue 和 Synchronous,线程池的排队策略与 BlockingQueue有关
                           ThreadFactory threadFactory,//线程工厂,主要用来创建线程,默认为正常优先级、非守护线程
                           RejectedExecutionHandler handler) {//

拒绝策略,拒绝处理任务时的策略,系统提供了 4 种可选:

AbortPolicy:拒绝并抛出异常。
CallerRunsPolicy:使用当前调用的线程来执行此任务。
DiscardOldestPolicy:抛弃队列头部(最旧)的一个任务,并执行当前任务。
DiscardPolicy:忽略并抛弃当前任务。
默认策略为 AbortPolicy

     // 省略...
 }

线程池执行流程:

1)当一个任务到来的时候如何它的核心线程数即corePoolSize没满的话,就会创建一个核心线程去执行该任务

  (2)   如何核心线程数满了,并仍有任务提交,则将任务先放入阻塞队列中

  (3)   阻塞队列已无空闲,还有任务继续提交,若最大线程数没有满的话,则会新建非核心线程并分配任务

  如果核心线程数、阻塞队列、最大线程数都满了的话,就会执行线程池的拒绝策略,一共有4种方式:

  (1)直接丢弃任务

  (2)丢弃任务并抛出异常(默认)

  (3) 将阻塞队列的头节点丢弃,然后尝试将任务放入队列中

  (4) 将任务交由主线程即调用者来执行该任务

可重入锁的作用就是为了避免死锁,java中synchronized和ReentrantLock都是可重入锁

3  为什么CAS比synchronized效率高?

答:因为synchronized会发生线程上下文切换,即线程a已经得到锁,线程b这时是可运行状态,线程b就会阻塞住,从可运行状态切换到阻塞状态。耗时。

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

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

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