java并发你必须会的编程

最新推荐文章于 2020-08-29 18:45:38 发布
最新推荐文章于 2020-08-29 18:45:38 发布
阅读量422 收藏
点赞数
分类专栏： java

1.  Fork/Join框架

 

Fork/Join框架是JDK7提供的一个用于并行执行任务的框架，是一个把大任务切分为若干子任务并行的执行，最终汇总每个小任务后得到大任务结果的框架。我们再通过Fork和Join来理解下Fork/Join框架。Fork就是把一个大任务划分成为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。

使用Fork/Join框架时，首先需要创建一个ForkJoin任务，它提供在任务中执行fork()和join操作的机制。通常情况下，我们不需要直接继承ForkJoinTask，只需要继承它的子类，Fork/Join框架提供了两个子类：RecursiveAction用于没有返回结果的任务；RecursiveTask用于有返回结果的任务。ForkJoinTask需要通过ForkJoinPool来执行。

任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。（工作窃取算法work-stealing）

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;


public class CountTask extends RecursiveTask<Integer>{
private static final int THRESHOLD = 10;
private int start;
private int end;

public CountTask(int start,int end){
this.start=start;
this.end=end;
}

protected Integer compute() {
int sum = 0;
boolean canCompute = (end-start) <= THRESHOLD;
        if(canCompute){
            for(int i=start;i<=end;i++){ sum += i; }
        }
        else{
            int middle = (start+end)/2;
            CountTask leftTask = new CountTask(start,middle);
            CountTask rightTask = new CountTask(middle+1,end);
            leftTask.fork();//将任务放入队列并安排异步执行，一个任务应该只调用一次fork()函数，除非已经执行完毕并重新初始化。
            rightTask.fork();//等待计算完成并返回计算结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
            sum = leftResult+rightResult;
        }
        return sum;
}

public static void main(String [] args) throws InterruptedException, ExecutionException{
ForkJoinPool forkJoinPool = new ForkJoinPool();
CountTask task = new CountTask(1,100);
Future<Integer> result = forkJoinPool.submit(task);// RecursiveTask<V> extends ForkJoinTask<V>
System.out.println(result.get());// ForkJoinTask<T> submit(ForkJoinTask<T> task) {

if(task.isCompletedAbnormally()){
         System.out.println(task.getException());
    }
}
}

2. 锁降级

锁降级是指写锁降级成读锁。如果当前线程拥有写锁，然后将其释放，最后获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，最后释放（先前拥有的）写锁的过程。参考下面的示例：

private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();
    private volatile static boolean update = false;

    public void processData()
    {
        r.lock();
        if(!update)
        {
            //必须先释放读锁
            r.unlock();
            //锁降级从写锁获取到开始
            w.lock();
            try
            {
                if(!update)
                {
                    //准备数据的流程（略）
                    update = true;
                }
                r.lock();
            }
            finally
            {
                w.unlock();
            }
            //锁降级完成，写锁降级为读锁
        }

        try
        {
            //使用数据的流程（略）
        }
        finally
        {
            r.unlock();
        }
    }

锁降级中的读锁是否有必要呢？答案是必要。主要是为了保证数据的可见性，如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程（T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。

3 . 实现线程安全的SimpleDateFormat

package ThreadLocalTest;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {

private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
private static ThreadLocal threadLocal = new ThreadLocal(){
  protected synchronized Object initialValue() {
            return new SimpleDateFormat(DATE_FORMAT);
        }
};

    public static DateFormat getDateFormat() {
        return (DateFormat) threadLocal.get();
    }

    public static Date parse(String textDate) throws ParseException {
        return getDateFormat().parse(textDate);
    }
}

<p>System.out.println(DateUtil.getDateFormat().format(newDate()));//输出当前日期</p>

点击打开链接

4.Callable& Future

Callable一般是和ExecutorService配合来使用的

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

也就是说Future提供了三种功能：

1）判断任务是否完成；

2）能够中断任务；

3）能够获取任务执行结果。

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


public class CallableAndFuture {

public static void main(String[] args) {
Callable<Integer>callable = new Callable<Integer>() {

@Override
public Integer call() throws Exception {
return new Random().nextInt(50);
}
};

FutureTask<Integer> f = new FutureTask<Integer>(callable);
new Thread(f).start();

try {
Thread.sleep(1000);
System.out.println(f.get());
} catch (InterruptedException e) {
e.printStackTrace();
}catch (ExecutionException e) {
e.printStackTrace();
}

}
}

5. 线程池

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
for (int i = 1; i 10; i++) {  
    final int index = i;  
    fixedThreadPool.execute(new Runnable() {  
         @Override  
         public void run() {  
             String threadName = Thread.currentThread().getName();  
             Log.v("zxy", "线程："+threadName+",正在执行第" + index + "个任务");  
             try {  
                    Thread.sleep(2000);  
             } catch (InterruptedException e) {  
                    e.printStackTrace();  
             }  
         }  
     });  
 }

点击打开链接

6. 写一个死锁程序

public class Test {

static Object obj1=new Object();
static Object obj2=new Object();

private static void fun1(){
synchronized (obj2) {
synchronized (obj1) {
//业务逻辑
}
}
}

private static void fun2(){
synchronized (obj1) {
synchronized (obj2) {
}
}
}
}
//然后执行的时候只需要开两个线程同时执行fun1和fun2就行了~

一般造成死锁必须同时满足如下4个条件：

1，互斥条件：线程使用的资源必须至少有一个是不能共享的；

2，请求与保持条件：至少有一个线程必须持有一个资源并且正在等待获取一个当前被其它线程持有的资源；

3，非剥夺条件：分配资源不能从相应的线程中被强制剥夺；

4，循环等待条件：第一个线程等待其它线程，后者又在等待第一个线程。

因为要产生死锁，这4个条件必须同时满足，所以要防止死锁的话，只需要破坏其中一个条件即可。

7.  生产者消费者问题

1. 阻塞队列实现：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class ProducerConsumerPattern {
 
    public static void main(String args[]){
 
     BlockingQueue sharedQueue = new LinkedBlockingQueue();

     Thread prodThread = new Thread(new Producer(sharedQueue));
     Thread consThread = new Thread(new Consumer(sharedQueue));

     prodThread.start();
     consThread.start();
    }
 
}
 
//Producer Class in java
class Producer implements Runnable {
 
    private final BlockingQueue sharedQueue;
 
    public Producer(BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }
 
    @Override
    public void run() {
        for(int i=0; i<10; i++){
            try {
                System.out.println("Produced: " + i);
                sharedQueue.put(i);
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
}
 
//Consumer Class in Java
class Consumer implements Runnable{
 
    private final BlockingQueue sharedQueue;
 
    public Consumer (BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }
 
    @Override
    public void run() {
        while(true){
            try {
                System.out.println("Consumed: "+ sharedQueue.take());
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
}

wait\notify实现

public class Dept {

private int capacity;// 容量
private int size;// 数量

public Dept(int capacity) {
this.capacity = capacity;
}

public synchronized void produce(int val) {

try {
int left = val;// left表示“想要生产的数量”
while (left > 0) {
while (size >= capacity)
// 库存已满时，等待“消费者”消费产品。
wait();

// 获取“实际生产的数量”(即库存中新增的数量)
// 如果“库存”+“想要生产的数量”>“总的容量”，则“实际增量”=“总的容量”-“当前容量”。(此时填满仓库)
// 否则“实际增量”=“想要生产的数量”
int inc = (size + left) > capacity ? (capacity - size) : left;
size += inc;
left -= inc;

System.out.printf(
"%s  生产：(%3d) --> 剩余=%3d, 该次生产数量=%3d, 当前仓库数量=%3d\n",
Thread.currentThread().getName(), val, left, inc, size);

notifyAll();// 通知消费者可以消费了

}
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public synchronized void consume(int val) {
try {
// left 表示“客户要消费数量”(有可能消费量太大，库存不够，需多此消费)
int left = val;
while (left > 0) {
// 库存为0时，等待“生产者”生产产品。
while (size <= 0)
wait();
// 获取“实际消费的数量”(即库存中实际减少的数量)
// 如果“库存”<“客户要消费的数量”，则“实际消费量”=“库存”；
// 否则，“实际消费量”=“客户要消费的数量”。
int dec = (size < left) ? size : left;
size -= dec;
left -= dec;
System.out.printf(
"%s 消费(%3d) <-- 需求量=%3d, 实际消费=%3d, 仓库剩余=%3d\n",
Thread.currentThread().getName(), val, left, dec, size);
notifyAll();
}
} catch (InterruptedException e) {
}
}

public String toString() {
return "capacity:" + capacity + ", actual size:" + size;
}
}
public class Producer {

     private Dept dept;

      public Producer(Dept dept) {
          this.dept = dept;
      }

     // 消费产品：新建一个线程向仓库中生产产品。
      public void produce(final int val) {
          new Thread() {
              public void run() {
                  dept.produce(val);
              }
          }.start();
      }
}
public class Customer {

     private Dept dept;

      public Customer(Dept depot) {
          this.dept = depot;
      }

     // 消费产品：新建一个线程从仓库中消费产品。
      public void consume(final int val) {
          new Thread() {
              public void run() {
                  dept.consume(val);
              }
          }.start();
      }
}
public class TestDemo1 {

public static void main(String[] args) throws InterruptedException {

         Dept mDepot = new Dept(100);
         Producer mPro = new Producer(mDepot);
         Customer mCus = new Customer(mDepot);

         mPro.produce(60);

         Thread.sleep(1000);

         mPro.produce(120);
         Thread.sleep(1000);
         mCus.consume(90);
         Thread.sleep(1000);
         mCus.consume(150);
         Thread.sleep(1000);
         mPro.produce(110);
}

}
老司儿
关注
专栏目录
第二章 线程的并发工具类笔记
hankin的博客
06-01 272
一、 Fork/Join框架的介绍 Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。我们再通过Fork和Join这两个单词来理解下Fork/Join框架，Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+。。＋10...
零基础java自学流程-Java语言高级447
Limingmingaa的博客
01-26 388
4.4 Fork/Join框架的异常处理 ForkJoinTask在执行的时候可能会抛出异常，但是我们没办法在主线程里直接捕获异常，所以ForkJoinTask提供了isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了，并且可以通过ForkJoinTask的getException方法获取异常。使用如下代码： if(task.isCompletedAbnormally()){ System.out.println(task.getException());
并发编程：fork/join框架：在任务中抛出异常
博风_刺耳的博客
08-29 1289
在任务中抛出异常，主程序中判断异常。
java并发编程实战源码,java并发编程实战pdf,Java
09-10
通过学习《Java并发编程实战》的源码，你可以更直观地了解这些概念如何在实际代码中实现，从而提升你的并发编程能力。在IDE中运行这些示例，可以加深对并发原理的理解，同时也能锻炼解决问题的能力。记住，实践是...
java并发编程实践pdf笔记
最新发布
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
java并发编程2
02-15
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释： 1. **线程与并发** - **线程*...
java并发编程
01-20
Java并发编程是Java开发者必须掌握的关键技能之一，它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的计算能力，提高应用程序的响应速度和整体性能。《Java编程并发实战》这本书是...
Java 并发编程实战.pdf
05-28
书中会首先介绍Java并发编程的基础知识，包括线程的创建和运行，同步机制的基本用法，以及Java内存模型的相关概念。随着章节的深入，作者可能会更深入地讲解Java提供的并发工具，例如锁、原子变量、线程池、以及并发...
RecursiveTask 例子
dzh145的专栏
04-27 349
1、普通单线程累加例子 package ForkJoinTest; import java.util.Random; public class MakeArray { public static final int ARRAY_LENGTH= 400000000; public static final int THRESHOLD= 47; public ...
Fork/Join框架（五）在任务中抛出异常
weixin_34353714的博客
04-08 388
在任务中抛出异常 在Java中有两种异常： 已检查异常（Checked exceptions）：这些异常必须在一个方法的throws从句中指定或在内部捕捉它们。比如：IOException或ClassNotFoundException。 未检查异常（Unchecked exceptions）：这些异常不必指定或捕捉。比如：NumberFormatExc...
Java面试，你必须要会的（一）、总纲
u012843361的博客
07-04 1311
Java面试，你必须要回的 从以下几个大类去归纳总结javaweb开发人员必备知识点 事先约定好必备知识的掌握程度，我把他分为5个层次精通、熟练、熟悉、略懂、不懂。 按照javaweb分层来讲，我们把知识点分为： 前端：前端包括了简单的html+css+js ，http规范、模板引擎 后端：java语法、数据结构、常用javaweb框架、常见web容器、设计模式、jvm、linux使用、...
使用Fork/Join框架在任务中抛出异常
07-10 2325
在java当中，异常一共分为两种。一种是运行时异常，一种是非运行是异常。 非运行时异常：这些异常必须在方法上通过throws子句抛出。或者在方法体内进行try{…}catch{…}来捕获异常。 运行时异常:这些方法不需要在throws子句抛出，也不需要在方法体内进行try{}catch{}操作。在ForkJoin框架中声明的compute()方法不允许在运行是抛出异常，因为这个方法的实现没有包含
Fork/Join框架
qq_34622428的博客
08-10 114
Fork/Join框架 java7提供的一个用于并行执行的框架，是一个把大任务拆分成若干个小任务，然后把小任务的结果汇总得到大任务结果的框架。 工作窃取算法 定义：指某个线程从其他队列里窃取任务来执行。 因为fork会将大任务分成若干个小的任务，然后为了减少线程之间的竞争，会将这些子任务放入到不同的队列中，并为每个队列创建一个单独的线程来执行。当某线程的队列任务执行完时，可以去其他队列里窃取任务来处理。 为了减少窃取任务线程和被窃取任务的线程之间的线程，任务队列一般采用双端队列的设计，被窃取任务线程从
Fork/join框架
大鹏的博客
08-08 252
Fork：就是把大任务分割成若干个子任务并行的执行/Join就是合并这些子任务的执行结果。 工作窃取算法：某个线程从其他队列里窃取任务来执行。被窃取任务线程永远从双端队列头部执行任务，而窃取任务的线程永远从双端队列的尾部拿任务执行。 工作窃取算法优点：充分利用线程进行并行计算减少了线程间的竞争。 工作窃取算法缺点：在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且该算法会消耗了更多
Fork/Join中的异常处理
cpf2016的专栏
12-03 1747
（1）继承关系               ThreadPoolExecutor：                             ForkJoinPool                                 可以看出他们的父类都是AbstractExecutorService，所以也ForkJoinPool可以通过execute和submit来执行线程
java并发编程实战第五章（4）在任务中抛出异常
程序男的专栏
08-16 812
4、在任务中抛出异常 1.非运行时异常：必须在方法上通过throws子句抛出，或者在方法体内通过try,catch方式进行捕捉处理，比如IOException或者 ClassNotFounException异常。 2.运行时异常：z这些异常不需要在方法上通过throws处理，也不需要try,catch处理。 说明：不能再ForkJoin类中的compute()
Callable接口解析
sunp823的专栏
06-02 277
1.接口的定义： public interface Callable&lt;V&gt; { V call() throws Exception; } 2.Callable和Runnable的异同 先看下Runnable接口的定义 public interface Runnable { public abstract void run(); } ...
Java并发编程深度解析
"Java并发编程-方腾飞魏鹏程晓明著" ...《Java并发编程的艺术》是一本深入浅出、理论与实践相结合的并发编程教材，无论你是初学者还是经验丰富的开发者，都能从中受益匪浅，提升自己的并发编程能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值