java线程新特性

最新推荐文章于 2023-02-02 21:13:52 发布
最新推荐文章于 2023-02-02 21:13:52 发布
阅读量147 收藏
点赞数
分类专栏： java_thread 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjianlinsb/article/details/84011411
版权

ExecutorService 

package thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ExecutorsServiceThread {

    public static void main(String[] args) {
        //ExecutorService pool = Executors.newFixedThreadPool(2);//固定大小的线程池
        //ExecutorService pool = Executors.newSingleThreadExecutor();//单个工作线程,以上两个线程池都是固定大小的，添加线程超过大小限制后就会自动增加到队列中等待，一旦有线程池中有完成的线程，则排队等待的线程就会入池执行
        //ExecutorService pool = Executors.newCachedThreadPool();
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        //ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();//单任务延迟线程池
        //ThreadPoolExecutor pool2=new ThreadPoolExecutor(corePoolSize, //池中保存的线程数，包括空闲线程
        //maximumPoolSize,//池中允许的最大线程数
        //keepAliveTime, //当线程数大于核心时，此为终止前 多余的空闲线程等待新任务的最长时间。
        //TimeUnit.DAYS, //时间的单位
        //workQueue);//任务队列
        BlockingQueue<Runnable> block = new ArrayBlockingQueue<Runnable>(20);
        ThreadPoolExecutor pool3 = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, block);
        Thread t1 = new ExecutorsThread("t1");
        Thread t2 = new ExecutorsThread("t2");
        Thread t3 = new ExecutorsThread("t3");
        Thread t4 = new ExecutorsThread("t4");
        Thread t5 = new ExecutorsThread("t5");
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t1);
        pool.schedule(t5, 10, TimeUnit.SECONDS);//参数：要执行的任务，从现在开始延迟的时间，时间的单位
        pool.shutdown();
        pool3.execute(t1);
        pool3.execute(t2);
        pool3.execute(t3);
        pool3.execute(t4);
        pool3.shutdown();
//        ThreadFactory factory=new ThreadFactory() {
//
//            @Override
//            public Thread newThread(Runnable r) {
//                return new Thread(r);
//            }
//        };
//        factory.
    }
}

class ExecutorsThread extends Thread {

    public String name;

    public ExecutorsThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        //while (true) {
        System.out.println(name + " is running......");
        try {
            sleep(1000);
            // }
        } catch (InterruptedException ex) {
            Logger.getLogger(ExecutorsThread.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

 带返回结果的线程 

//下面的executer 还有一个 List<Future<T>>  invokeAll(Collection<Callable<T>> tasks)方法，执行完所有任务后可将结果保存致list中返回，比便后续处理

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableThread {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executer = Executors.newFixedThreadPool(2);
        CallThread callable1 = new CallThread("1111");
        CallThread callable2 = new CallThread("2222");
        Future<String>f1=executer.submit(callable1);//当执Callable任务后将返回结果保存到Future对象中
        Future<String>f2=executer.submit(callable2);
        System.out.println(f1.get());
        System.out.println(f2.get());
        executer.shutdown();
    }
}
/**
 * 有返回值的任务
 */
class CallThread implements Callable<String> {//可返回值的任务必须实现Callble接口
    private String name = "";
    public CallThread(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        return name;
    }
}
 

阻塞队列

 

package thread;
//
//import java.util.Random;

import java.lang.reflect.Field;
import java.util.Random;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;

public class BlockingQueueThread {

    public static void main(String[] args) {
        BlockingQueue queue = new ArrayBlockingQueue(5);
        ExecutorService pool = Executors.newFixedThreadPool(15);
        PutThread[] blockThread = new PutThread[10];
        TakeThread[] takeThread = new TakeThread[5];
        Lock lock = new ReentrantLock();
        Lock takeLock = new ReentrantLock();
        for (int i = 0; i < takeThread.length; i++) {
            takeThread[i] = new TakeThread(queue, "thread" + i, takeLock);
            pool.execute(takeThread[i]);
        }
        for (int i = 0; i < blockThread.length; i++) {
            blockThread[i] = new PutThread(queue, "thread" + i, lock);//在此处takeThread和putThread内加不同锁不能保证打印时的正确性，因为执行put后
                                                                      //可能已经有take线程从queue中取数据。因此打印的结果看似add都在一块，但数据不是递增的
                                                                      //如果加同一个锁的话那就会阻塞：当put满或take空时queue会让其等待，但有拿着锁，而take
                                                                      //或put进不到queue中无法继续执行，一直等待。
                                                                      //结论：用BlockQueue put 或take 还想同时拿到其内部数据多少时不可行的。
                                                                      //以上结论是不对滴：以下注释中有个非主流的做法
            pool.execute(blockThread[i]);
        }
        pool.shutdown();
    }
}

class PutThread extends Thread {

    private BlockingQueue queue;
    private String name;
    private Lock lock;

    public PutThread(BlockingQueue queue, String name, Lock lock) {
        this.queue = queue;
        this.name = name;
        this.lock = lock;
    }

    @Override
    public void run() {
        while (true) {
            lock.lock();
            Integer i = new Random().nextInt(10) + 1;
            try {
                queue.put(i);//此处应用put take 。如果用add时，成功返回true，失败则抛出异常
            } catch (InterruptedException ex) {
                Logger.getLogger(PutThread.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                lock.unlock();
            }
            System.out.println(this.getName() + " add " + i + " ......" + queue.size());
        }

    }
}

class TakeThread extends Thread {

    private BlockingQueue queue;
    private String name;
    private Lock lock;

    ;

    public TakeThread(BlockingQueue queue, String name, Lock lock) {
        this.queue = queue;
        this.name = name;
        this.lock = lock;
    }

    @Override
    public void run() {
        while (true) {
            lock.lock();
            Integer i = 0;
            try {
                i = (Integer) queue.take();
                System.out.println(this.getName() + " take " + i + " ......" + queue.size());
            } catch (InterruptedException ex) {
                Logger.getLogger(PutThread.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                lock.unlock();
            }

        }
    }
}
//public class BlockingQueueThread {
//
//    public static ReentrantLock getLock(BlockingQueue queue) throws Exception {
//        Field fields[] = queue.getClass().getDeclaredFields();
//        for (Field f : fields) {
//            f.setAccessible(true);
//            if (f.getName().equals("lock")) {
//                return (ReentrantLock) f.get(queue);
//            }
//        }
//        return null;
//    }
//    public static void main(String[] args) throws Exception {
//        BlockingQueue queue = new ArrayBlockingQueue(10);
//        ExecutorService pool = Executors.newFixedThreadPool(15);
//        PutThread[] blockThread = new PutThread[10];
//        TakeThread[] takeThread = new TakeThread[5];
//        Object lock = new Object();
//        Object takeLock = new Object();
//        try {
//            lock = getLock(queue);
//            takeLock = lock;
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        for (int i = 0; i < takeThread.length; i++) {
//            takeThread[i] = new TakeThread(queue, "thread" + i, takeLock);
//            pool.execute(takeThread[i]);
//        }
//        for (int i = 0; i < blockThread.length; i++) {
//            blockThread[i] = new PutThread(queue, "thread" + i, lock);
//            pool.execute(blockThread[i]);
//        }
//        pool.shutdown();
//    }
//}
//
//class PutThread extends Thread {
//
//    private BlockingQueue queue;
//    private String name;
//    private Object lock;
//
//    public PutThread(BlockingQueue queue, String name, Object lock) {
//        this.queue = queue;
//        this.name = name;
//        this.lock = lock;
//    }
//
//    @Override
//    public void run() {
//        while (true) {
//            try {
//                Thread.sleep(1000);
//            } catch (Exception ex) {
//                ex.printStackTrace();
//            }
//            // synchronized (lock) {
//            try {
//                ((ReentrantLock) lock).lock();
//                Integer i = new Random().nextInt(10) + 1;
//                try {
//                    queue.put(i);// 此处应用put take 。如果用add时，成功返回true，失败则抛出异常
//                } catch (InterruptedException ex) {
//                    Logger.getLogger(PutThread.class.getName()).log(
//                            Level.SEVERE, null, ex);
//                }
//                System.out.println(this.getName() + " add " + i + " ......"
//                        + queue.size());
//            } catch (Exception e) {
//                e.printStackTrace();
//            } finally {
//                ((ReentrantLock) lock).unlock();
//            }
//            // }
//        }
//
//    }
//}
//
//class TakeThread extends Thread {
//
//    private BlockingQueue queue;
//    private String name;
//    private Object lock;
//
//    public TakeThread(BlockingQueue queue, String name, Object lock) {
//        this.queue = queue;
//        this.name = name;
//        this.lock = lock;
//    }
//
//    @Override
//    public void run() {
//        while (true) {
//            try {
//                Thread.sleep(1000);
//            } catch (Exception ex) {
//                ex.printStackTrace();
//            }
//            // synchronized (lock) {
//            try {
//                ((ReentrantLock) lock).lock();
//                Integer i = 0;
//                try {
//                    i = (Integer) queue.take();
//                } catch (InterruptedException ex) {
//                    Logger.getLogger(PutThread.class.getName()).log(
//                            Level.SEVERE, null, ex);
//                }
//                System.out.println(this.getName() + " take " + i + " ......"
//                        + queue.size());
//            } catch (Exception e) {
//                e.printStackTrace();
//            } finally {
//                ((ReentrantLock) lock).unlock();
//            }
//            // }
//        }
//    }
//}

 

 

每任务每线程 

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletionServiceThread {

    public static void main(String[] args) {
        List<String> abc = new ArrayList<String>();
        abc.add("11");
        abc.add("233322");
        abc.add("3rdddddr33");
        abc.add("4rr44");
        abc.add("54554545");
        abc.add("5555544444444444");
        ExecutorService executor = Executors.newFixedThreadPool(2);
        CompletionService service = new ExecutorCompletionService(executor);
        for (final String s : abc) {//每个字符串分别获得一个线程进行处理，假设处理字符串需要时间较长
            service.submit(new Callable() {//提交一批希望得到结果的任务
                @Override
                public Object call() throws Exception {
                    Thread.sleep(5000);
                    if(s.equals("11")){
                        throw new Exception();
                    }
                    return Thread.currentThread().getName()+" "+s + "   " + s.length() + "";
                }
            });
        }
        for(int i=0;i<abc.size();i++){
            try {
                Future<String> future=service.take();//检索并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
                String a=future.get();
                System.out.println(a);//处理已完成的任务
            } catch (ExecutionException ex) {
                Logger.getLogger(CompletionServiceThread.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InterruptedException ex) {
                Logger.getLogger(CompletionServiceThread.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        executor.shutdown();
    }
}
/**
 * 某次运行结果：
 * pool-1-thread-1 11   2
   pool-1-thread-2 233322   6
   pool-1-thread-1 3rdddddr33   10
   pool-1-thread-2 4rr44   5
   pool-1-thread-1 54554545   8
   pool-1-thread-2 5555544444444444   16
 */

 

主线程等从线程 

package thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class BarrierThread {

    public static void main(String[] args) {
        ThreadFactory a;
        CyclicBarrier barrier = new CyclicBarrier(3, new MainThread());//当有一个线程需要等待其他线程指向完毕后才能执行时可用此类
        ExecutorService pool = Executors.newFixedThreadPool(3);
        pool.execute(new SubThread(barrier));
        pool.execute(new SubThread(barrier));
        pool.execute(new SubThread(barrier));
        pool.shutdown();
    }
}

class MainThread extends Thread {

    @Override
    public void run() {
        System.out.println("I'm here....");
    }
}

class SubThread extends Thread {

    private CyclicBarrier barrier;

    public SubThread(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + " is running " + i);
        }
        try {
            barrier.await();
        } catch (InterruptedException ex) {
            Logger.getLogger(SubThread.class.getName()).log(Level.SEVERE, null, ex);
        } catch (BrokenBarrierException ex) {
            Logger.getLogger(SubThread.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

 awaitTermination方法的使用 

package thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class AwaitTerminationThread {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);

        service.submit(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println(Thread.currentThread().getName()+"bbbbb " + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(AwaitTerminationThread.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        });
        service.submit(new Runnable() {
//           new Thread.UncaughtExceptionHandler(){
//               
//           };
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println(Thread.currentThread().getName()+" aaaaaa " + i);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(AwaitTerminationThread.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        });
        service.shutdown();
        try {
            service.awaitTermination(10, TimeUnit.SECONDS);//开始10秒时如果任务未完成一直阻塞让service submit的任务先执行完
        } catch (InterruptedException ex) {
            Logger.getLogger(AwaitTerminationThread.class.getName()).log(Level.SEVERE, null, ex);
        }
        while (true) {
            System.out.println("11111");
        }
    }
}

集合迭代时抛出的异常 

package thread;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ConcurrentModificationExceptionTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("1111");
        list.add("222");
        list.add("3333");
        Iterator iterator=list.iterator();
        while(iterator.hasNext()){
            if(iterator.next().equals("222")){
                iterator.remove();
                list.add("555");//此处会有异常，迭代过程中迭代器对ArrayList做了修改后在迭代器内再通过list对集合做修改会抛异常
                /**
                 * 抛异常的标准就是modCount != expectedModCount
                 * 在Itr类的成员变量里对expectedModCount初始化的赋值是int expectedModCount = modCount Itr 是在执行iterator方法是返回的迭代器
                 * 组若这个过程中list中有add remove等操作就会使modCount这两个值不同，就会会抛出异常
                 */
                
            }
        }
        list.add("4444");
        System.out.println(list);
    }
}

  例子：三个线程按顺序执行

方法一：

//转.......
package thread;
public class ABCThread extends Thread{
    private static Object o = new Object();
    private static int count = 0;
    private char ID;
    private int id;
    private int num = 0;
    public ABCThread(int id, char ID) {
        this.id = id;
        this.ID = ID;
    }

    public void run() {
        synchronized (o) {
            while (num < 10) {
                if (count % 3 == id) {//将count与线程id联系起来，count为0 3 6 9......时才会执行线程A，其它线程wait(),count为1,4,7...时执行线程1
                    System.out.println(ID);
                    ++count;
                    ++num;

                    o.notifyAll();

                }
                else {
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        (new ABCThread(2, 'C')).start();
        (new ABCThread(0, 'A')).start();
        (new ABCThread(1, 'B')).start();
        
    }
}
 

方法二：

 

//转
package thread;

import java.text.DateFormat;
import java.util.concurrent.Semaphore;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ABCMyThread extends Thread {

    int count = 10;
    String name;
    Semaphore current;
    Semaphore next;

    public ABCMyThread(String name, Semaphore current, Semaphore next) {
        this.name = name;
        this.next = next;
        this.current = current;

    }

    @Override
    public void run() {
        while (count > 0) {
            try {
                this.current.acquire();
            } catch (InterruptedException ex) {
                Logger.getLogger(ABCMyThread.class.getName()).log(Level.SEVERE, null, ex);
            }
            System.out.println(this.name);
            count--;
            this.next.release();
        }
    }

    public static void main(String[] args) {
//        Semaphore a = new Semaphore(1);
//        Semaphore b = new Semaphore(0);
//        Semaphore c = new Semaphore(0);
//        Thread t1=new ABCMyThread("A",a,b);//t1进程用a信号量acquire可允许一个线程进入（即t1线程）,如果t1循环执行一次后又到acquire，时不能往下执行，需等t3的a信号量执行release
//        Thread t2=new ABCMyThread("B",b,c);//t2线程用b信号量qcquire不允许任何线程进入，所以会等t1线程的b信号量执行release时才可运行
//        Thread t3=new ABCMyThread("C",c,a);//.....
//        t1.start();
//        t2.start();
//        t3.start();
        //DateFormat format=new DateFormat() {};
       

    }
}
 
chenjianlinsb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
什么是 RDD ？
weixin_34179968的博客
05-23 562
Spark 中最基本的数据抽象是 RDD。 RDD：弹性分布式数据集 (Resilient Distributed DataSet)。 1，RDD 有三个基本特性 这三个特性分别为：分区，不可变，并行操作。 a， 分区 每一个 RDD 包含的数据被存储在系统的不同节点上。逻辑上我们可以将 RDD 理解成一个大的数组，数组中的每个元素就代表一个分区 (Partition) 。 在物理存储中，每个分区...
【蓝桥杯】搜索专题总结——真题讲解
xubenshan的博客
03-06 4052
更新啦更新啦~对蓝桥杯搜索题目的讲解~
1. 理解 RDD、DataFrame、DataSet、DStream
最新发布
doing a 责任心 dataer
02-02 634
理解 RDD、DataFrame、DataSet、DStream
线程基础：JDK1.5+（8）——线程新特性（上）
JAVA入门中
02-13 8487
JDK1.5中一个重要特性就是util.concurrent包和其子包（当让JDK1.5中的特性还包括了很多，例如泛型、解包/封包等，但这些不属于我们这个专题讨论的范围）。在这个系列的专题中，我们已经对util.concurrent包中的一些主要功能做了介绍，例如：BlockingQueue、ThreadPoolExecutor、Executors等。这篇文章中，我们对这个包中其他中要的线程特性进行介绍。
线程基础：JDK1.5+（10）——线程新特性（下）
02-17 284
（接上文《线程基础：JDK1.5+（9）——线程新特性（中）》） 3-4、CountDownLatch：同步器 上文...
Java线程优先级示例代码
09-05
Java线程的优先级范围是从1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY），默认情况下，每个新创建的线程都继承其父线程的优先级，通常是5（Thread.NORM_PRIORITY）。在Java中，可以使用`setPriority()`方法...
Java线程安全
02-23
首先，Java并发的问题要从JMM（JavaMemoryModel）讲起，先上一张JMM的结构图：在Java内存模型中，分为主内存和线程工作内存，线程使用共享数据时，都是先从主内存中拷贝到工作内存，使用完成之后再写入主内存，可以...
java多线程进度条
02-10
在Java编程中，多线程是一项关键特性，它允许程序同时执行多个任务，提升系统效率。在处理耗时操作如大文件下载、数据处理或网络请求时，展示进度条能够提供用户友好的交互体验，让使用者了解任务的完成状态。本主题...
java线程.rar
07-26
Java线程是Java编程语言中...以上知识点覆盖了Java线程的基础概念、创建方式、状态管理、同步机制以及高级特性，是Java程序员必须掌握的重要内容。通过深入理解和熟练应用这些知识，可以编写出高效、安全的多线程程序。
多线程之八：并发调试和JDK8新特性
大鱼物联
06-08 3929
整理自炼数成金 源码连接： 到了这章，多线程的介绍也到尾声了，最后介绍一下多线程在Eclipse中是怎么调试的，还有常见问题的解决方案。 多线程调试的方法 使用Eclipse进行多线程调试 -条件断点 以上示例断点会中断当前线程，不影响其他线程的继续执行。这种调试方法...
java5 多线程新特性
wwwyuanliang10000的专栏
07-23 758
package com.main.thread; import java.util.concurrent.Callable; import java.util.concurrent.CompletionService; import java.util.concurrent.ExecutorCompletionService; import java.util.concurrent.Execut
Java多线程和JDK1.5多线程新特性
淡淡的博客
06-22 379
线程：一行行代码往下执行。 Thread  的 run() ,如果没被覆盖，且为Thread设置了Runnable对象，则会调用Runnable的run();   线程互斥与同步通信 线程安全问题可以用银行转账来说明。   线程同步：必须把锁加在同一对象上，或同一类上， 方法上加synchronized ，同一个对象的Wait();等待   notify();唤醒任意一个   线...
java 多线程 新特性_java-多线程新特性
weixin_39717865的博客
02-13 77
Java定时器相关Timer和TimerTask类每个Timer对象相对应的是单个后台线程，用于顺序地执行所有计时器任务TimerTask对象。Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data)，2:在某个固定的时间之后(long delay)，都可以指定任务执行的固定延迟(long period)。另一种是scheduleAtFixe...
jdk1.7线程并发的新特性
高级架构师
09-02 980
转载http://blog.csdn.net/aesop_wubo/article/category/1147178
【Java并发编程】之十九：并发新特性—Executor框架与线程池（含代码）
热门推荐
兰亭风雨的专栏
12-23 7万+
在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结
10、多线程（二） -- 线程新特性
weixin_34130389的博客
03-01 70
1.2、JDK1.5多线程新特性 JDK1.5新特性，针对全部唤醒机制导致本方被唤醒存在的隐患进行了修正。(锁的组合使用) 它其实就是一个替代品: 把隐式的锁改为显示的锁，可以人为操纵。 synchronized-->Lock:通过创建对象获得， Lock lock =newReentrantLock(); lock.lock();//同步,加锁 lock.unlock...
RDD 的概念和五大特性理解
Kingsley's Blog
11-01 1560
RDD 概念 A Resilient Distributed Dataset (RDD), the basic abstraction in Spark. Represents an immutable, partitioned collection of elements that can be operated on in parallel. RDD 是一个弹性分布式数据集 DataSet； 是一个抽象类； 表示一个可以进行并行操作的元素的不可变集合。 DataSet 可以理解成一个集合，集合
java8新特性--线程池
weixin_30355437的博客
05-09 334
线程池 转载于:https://www.cnblogs.com/luao/p/10837142.html
Java线程-新特性
jingmiaowill的专栏
11-25 652
这里总结一下1.5以后java线程的新特性内容。 具体使用和细节可以直接通过API查看。 这里只是总结一下都有什么内容。方便自己查看。 1.线程池 Executors 固定大小的线程池:ExecutorService pool = Executors.newFixedThreadPool(size); 单任务线程池:ExecutorService pool = Execu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值