Java并发基础总结

34人阅读 评论(0) 收藏 举报
分类:

并发是一种能并行运行多个程序或并行运行一个程序中多个部分的能力。如果程序中一个耗时的任务能以异步或并行的方式运行,那么整个程序的吞吐量和可 交互性将大大改善。现代的PC都有多个CPU或一个CPU中有多个核,是否能合理运用多核的能力将成为一个大规模应用程序的关键。

线程基本使用

  编写线程运行时执行的代码有两种方式:一种是创建Thread子类的一个实例并重写run方法,第二种是创建类的时候实现Runnable接口。当然,实现 Callable也算是一种方式,Callable和Future结合实现可以实现在执行完任务后获取返回值,而Runnable和Thread方式是无法获取任务执行后的结果的。

复制代码
public class ThreadMain {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        new Thread(myThread).start();

        new MyThreas2().start();
    }
}

// 第一种方式,实现Runable接口
class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println("MyThread run...");
    }
}

// 第二种方式,继承Thread类,重写run()方法
class MyThreas2 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread2 run...");
    }
}
复制代码

  一旦线程启动后start()方法会立即返回,而不会等待run()方法执行完毕后返回,就好像run方法是在另外一个cpu上执行一样。

注意:创建并运行一个线程所犯的常见错误是调用线程的run()方法而非start()方法,如下所示:

Thread newThread = new Thread(MyRunnable());
newThread.run();  //should be start();

  起初你并不会感觉到有什么不妥,因为run()方法的确如你所愿的被调用了。但是,事实上,run()方法并非是由刚创建的新线程所执行的,而是当前线程所执行了。也就是被执行上面两行代码的线程所执行的。想要让创建的新线程执行run()方法,必须调用新线程的start方法。

Callable和Future结合实现实现在执行完任务后获取返回值

复制代码
public static void main(String[] args) {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    Future<String> future = exec.submit(new CallTask());

    System.out.println(future.get());
}
class CallTask implements Callable {
    public String call() {
        return "hello";
    }
}
复制代码

给线程设置线程名:

MyTask myTask = new MyTask();
Thread thread = new Thread(myTask, "myTask thread");

thread.start();
System.out.println(thread.getName());

  当创建一个线程的时候,可以给线程起一个名字。它有助于我们区分不同的线程。

 

volatile

  在多线程并发编程中synchronized和Volatile都扮演着重要的角色,Volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值。它在某些情况下比synchronized的开销更小,但是volatile不能保证变量的原子性。

  volatile变量进行写操作时(汇编下有lock指令),该lock指令在多核系统下有2个作用:

  • 将当前CPU缓存行写回系统内存。
  • 这个写回操作会引起其他CPU缓存了改地址的数据失效。

  多CPU下遵循缓存一致性原则,每个CPU通过嗅探在总线上传播的数据来检查自己的缓存值是否过期了,当发现缓存对应的内存地址被修改,将对应缓存行设置为无效状态,下次对数据操作会从系统内存重新读取。更多volatile知识请点击深入分析Volatile的实现原理

 

synchronized

  在多线程并发编程中Synchronized一直是元老级角色,很多人都会称呼它为重量级锁,但是随着Java SE1.6对Synchronized进行了各种优化之后,有些情况下它并不那么重了。

  Java中每一个对象都可以作为锁,当一个线程试图访问同步代码块时,它首先必须得到锁,退出或抛出异常时必须释放锁。

  • 对于同步方法,锁是当前实例对象。
  • 对于静态同步方法,锁是当前对象的Class对象。
  • 对于同步方法块,锁是Synchonized括号里配置的对象。

  synchronized关键字是不能继承的,也就是说基类中的synchronized方法在子类中默认并不是synchronized的。当线程试图访问同步代码块时,必须先获得锁,退出或抛出异常时释放锁。Java中每个对象都可以作为锁,那么锁存在哪里呢?锁存在Java对象头中,如果对象是数组类型,则虚拟机用3个word(字宽) 存储对象头,如果对象是非数组类型,则用2字宽存储对象头。更多synchronized知识请点击Java SE1.6中的Synchronized

 

线程池

  线程池负责管理工作线程,包含一个等待执行的任务队列。线程池的任务队列是一个Runnable集合,工作线程负责从任务队列中取出并执行Runnable对象。

ExecutorService executor  = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
    executor.execute(new MyThread2());
}
executor.shutdown();

Java通过Executors提供了4种线程池:

  • newCachedThreadPool:创建一个可缓存线程池,对于新任务如果没有空闲线程就新创建一个线程,如果空闲线程超过一定时间就会回收。
  • newFixedThreadPool:创建一个固定数量线程的线程池。
  • newSingleThreadExecutor:创建一个单线程的线程池,该线程池只用一个线程来执行任务,保证所有任务都按照FIFO顺序执行。
  • newScheduledThreadPool:创建一个定长线程池,支持定时及周期性任务执行。

  以上几种线程池底层都是调用ThreadPoolExecutor来创建线程池的。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
  • corePoolSize(线程池的基本大小):当提交一个任务到线程池时,线程池会创建一个线程来执行任务,即使其他空闲的基本线程能够执行新任务也会创建线程,等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法,线程池会提前创建并启动所有基本线程。
  • maximumPoolSize(线程池最大大小):线程池允许创建的最大线程数。如果队列满了,并且已创建的线程数小于最大线程数,则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。
  • keepAliveTime(线程活动保持时间):线程池的工作线程空闲后,保持存活的时间。所以如果任务很多,并且每个任务执行的时间比较短,可以调大这个时间,提高线程的利用率。
  • TimeUnit(线程活动保持时间的单位):可选的单位有天(DAYS),小时(HOURS),分钟(MINUTES),毫秒(MILLISECONDS),微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)。,可以选择的阻塞队列有以下几种:
  • workQueue(任务队列):用于保存等待执行的任务的阻塞队列。

 

    • ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列,此队列按 FIFO(先进先出)原则对元素进行排序。
    • LinkedBlockingQueue:一个基于链表结构的阻塞队列,此队列按FIFO (先进先出) 排序元素,吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
    • SynchronousQueue:一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于LinkedBlockingQueue,静态工厂方法Executors.newCachedThreadPool使用了这个队列。
    • PriorityBlockingQueue:一个具有优先级得无限阻塞队列。

当提交新任务到线程池时,其处理流程如下:

  1. 先判断基本线程池是否已满?没满则创建一个工作线程来执行任务,满了则进入下个流程。
  2. 其次判断工作队列是否已满?没满则提交新任务到工作队列中,满了则进入下个流程。
  3. 最后判断整个线程池是否已满?没满则创建一个新的工作线程来执行任务,满了则交给饱和策略来处理这个任务。

 

查看评论

使用Delphi,SDK编写Windows简单程序

        接触Delphi也已经有好长时间了,使用Delphi进行程序开发非常方便、快速,Delphi本身就提供了大量的组件(网上还有更多的组件)进行程序开发,这大大减轻了程序员的工作量,但是越...
  • dyroro
  • dyroro
  • 2002-07-22 10:10:00
  • 1142

Java并发知识点总结(上)

系统的总结Java并发的基础知识。希望对大家有所帮助~
  • Zerohuan
  • Zerohuan
  • 2015-09-23 22:24:09
  • 885

<java并发编程实战>阅读总结(a)

锁(lock)与volatile (1)、隐式锁,java提供了强制原子性的内置锁机制:synchronized块或synchronized方法。 操作共享状态的复合操作必须是原子的,以避免竞态条件,...
  • zgaoq
  • zgaoq
  • 2017-01-24 17:51:57
  • 275

Java 并发基础

Java 并发基础标签: Java基础线程简述 线程是进程的执行部分,用来完成一定的任务; 线程拥有自己的堆栈,程序计数器和自己的局部变量,但不拥有系统资源, 他与其他线程共享父进程的共享资源及部...
  • hanqing280441589
  • hanqing280441589
  • 2016-01-24 23:08:53
  • 5653

《JAVA并发编程实践》读书笔记(一)

《JAVA并发编程实践》读书笔记(一)2016年8月1日,“妮妲”冲击广东,全市放假1天。托“妮妲”的福,终于有空将近期的阅读整理一下。 最近利用业余时间重读了Brian Goetz的书,觉得受益匪...
  • youngweiquan
  • youngweiquan
  • 2016-08-02 01:04:55
  • 869

java基础思维导图总结

  • 2016年03月05日 18:40
  • 15.08MB
  • 下载

《Java并发编程实战》- 个人阅读总结(一)

背景最近想更深入了解下Java多线程相关的知识,对Java多线程有一个全面的认识,所以想找一本Java多线程相关的书籍来阅读,最后我选择了《Java并发编程实战》这本个人认为还算相当不错,至于为什么选...
  • qq258513813
  • qq258513813
  • 2017-03-06 21:40:00
  • 1528

Java基础总结之各个模块重要知识点

一:对象模块。 一.初始化 1.对this.super,构造函数,构造代码块,静态代码块总结。 this:代表当前对象,也就是所在函数所属对象的引用。 this对象后面加.调用的是对象的成员变量和方法...
  • qq_19776363
  • qq_19776363
  • 2015-08-12 10:45:15
  • 10061

java并发大总结

引子: 在一个list中有过亿条的Integer类型的值,如何更快的计算这些值的总和? 要学习的东西那么多!扶我起来。。 慢慢来深入,慢慢来领略大牛的思想融汇。 注:本文汇集各方材料而成,...
  • basycia
  • basycia
  • 2016-07-28 18:31:04
  • 3904
    个人资料
    等级:
    访问量: 103
    积分: 22
    排名: 209万+
    文章分类
    文章存档