多线程

2018-05-24  本文已影响0人  bigfish1129

多线程

1.悲观锁和乐观锁

http://www.importnew.com/21037.html

JAVA ThreadPoolExecutor线程池参数设置技巧

https://www.imooc.com/article/5887

一、ThreadPoolExecutor的重要参数

  1. corePoolSize：核心线程数
  1. queueCapacity：任务队列容量（阻塞队列）
  1. maxPoolSize：最大线程数
  1. keepAliveTime：线程空闲时间
  1. allowCoreThreadTimeout：允许核心线程超时
  2. rejectedExecutionHandler：任务拒绝处理器

二、ThreadPoolExecutor执行顺序

线程池按以下行为执行任务

  1. 当线程数小于核心线程数时，创建线程。
  2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
  3. 当线程数大于等于核心线程数，且任务队列已满
    • 若线程数小于最大线程数，创建线程
    • 若线程数等于最大线程数，抛出异常，拒绝任务

三、如何设置参数

  1. 默认值
  1. 如何来设置

cpu 如何合理地估算线程池大小？

https://blog.csdn.net/coslay/article/details/42062571

  1. 计算过程很简单，每个线程的处理能力为0.25TPS，那么要达到20TPS，显然需要20/0.25=80个线程。
  2. 第二种简单的但不知是否可行的方法（N为CPU总核数）：
    如果是CPU密集型应用，则线程池大小设置为N+1
    如果是IO密集型应用，则线程池大小设置为2N+1
    如果一台服务器上只部署这一个应用并且只有这一个线程池，那么这种估算或许合理，具体还需自行测试验证。

守护线程(Daemon Thread)

在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。

所谓守护 线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。

用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。

将线程转换为守护线程可以通过调用Thread对象的setDaemon(true)方法来实现。在使用守护线程时需要注意一下几点：

ThreadLocal

https://www.zhihu.com/question/23089780
ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。
提供线程内部的局部变量，在本线程内随时随地可取，隔离其他线程。

Synchronized的用法

https://blog.csdn.net/luoweifu/article/details/46613015

  1. 修饰一个代码块
    一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。我们看下面一个例子：
/**
 * 同步线程
 */
class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public  void run() {
      synchronized(this) {
         for (int i = 0; i < 5; i++) {
            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }

   public int getCount() {
      return count;
   }
}
  1. 指定要给某个对象加锁
      synchronized (account) {
         account.deposit(500);
         account.withdraw(500);
         System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
      }
   }
  1. 修饰一个方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。

   for (int i = 0; i < 5; i ++) {
      try {
         System.out.println(Thread.currentThread().getName() + ":" + (count++));
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}
  1. 修饰一个静态的方法
    Synchronized也可修饰一个静态方法，用法如下：
public synchronized static void method() {
   // todo
}

我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

对象的notify方法的含义和对象锁释放的三种情况

1，notify的含义
（1）notify一次只随机通知一个线程进行唤醒
（2） 在执行了notify方法之后，当前线程不会马上释放该对象锁，呈wait状态的线程也不能马上获得该对象锁，
要等到执行notify方法的线程将程序执行完 ，也就是退出sychronized代码块后，当前线程才会释放锁，
而呈wait状态所在的线程才可以获取该对象锁。
2，对象锁释放的三种情况

序号 场景
1 执行完同步代码块就会释放对象的锁
2 在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放
3 在执行同步代码块的过程中，执行了锁所属对象的wait方法，这个线程会释放对象锁，而此线程对象会进入线程等待池中，等待被唤醒

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）

3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

java多线程状态机

(3) 为什么没有running状态和ready状态
(3) 死锁如何排查

(1) 简单说明Executor ExecutorService Executors ThreadPoolExecutor的关系

(3) jdk8之前三种常见的线程池特点 使用场景
fixedThreadPool
cachedThreadPool
singleThreadPool

(4) jdk8 workStealingThreadPool是什么？

fork/join框架

http://ifeve.com/talk-concurrency-forkjoin/

  1. 什么是Fork/Join框架
    Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。
  2. 工作窃取算法
    工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。
  3. Fork/Join框架的介绍
  1. Fork/Join使用两个类来完成以上两件事情：

ForkJoinTask：我们要使用ForkJoin框架，必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制，通常情况下我们不需要直接继承ForkJoinTask类，而只需要继承它的子类，Fork/Join框架提供了以下两个子类：
RecursiveAction：用于没有返回结果的任务。
RecursiveTask ：用于有返回结果的任务。
ForkJoinPool ：ForkJoinTask需要通过ForkJoinPool来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务

  1. Fork/Join框架的实现原理
    ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责存放程序提交给ForkJoinPool的任务，而ForkJoinWorkerThread数组负责执行这些任务。

ForkJoinTask的fork方法实现原理。当我们调用ForkJoinTask的fork方法时，程序会调用ForkJoinWorkerThread的pushTask方法异步的执行这个任务，然后立即返回结果。

pushTask方法把当前任务存放在ForkJoinTask 数组queue里。然后再调用ForkJoinPool的signalWork()方法唤醒或创建一个工作线程来执行任务。

ForkJoinTask的join方法实现原理。Join方法的主要作用是阻塞当前线程并等待获取结果。

首先，它调用了doJoin()方法，通过doJoin()方法得到当前任务的状态来判断返回什么结果，任务状态有四种：已完成（NORMAL），被取消（CANCELLED），信号（SIGNAL）和出现异常（EXCEPTIONAL）。

如果任务状态是已完成，则直接返回任务结果。
如果任务状态是被取消，则直接抛出CancellationException。
如果任务状态是抛出异常，则直接抛出对应的异常。

自己设计线程池

https://blog.csdn.net/seulzz/article/details/77430559

一，线程池的基本要素

线程池一般需要一个线程管理类： ThreadPoolManager，其作用有：

1）提供创建一定数量的线程的方法。主线程调用该方法，从而创建线程。创建的线程执行自己的例程，线程的例程阻塞在任务抓取上。

2）提供对任务队列的操作的方法。主线程调用初始化任务队列的方法，然后在有任务的时候，调用提供的任务添加方法，将任务添入等待队列。当主线程调用任务的添加方法时，会触发等待的线程，从而使得阻塞的线程被唤醒，其抓取任务，并执行任务。

线程池需要一个任务队列： List<Task>，其作用有：

提供任务的增删方法。而且该任务队列需要进行排他处理，防止多个工作线程对该任务队列进行同时的抓取操作或者主线程的加入与工作线程的抓取的并发操作。

线程池需要一个类似信号量的通知机制：wait -notify：

工作线程调用wait阻塞在任务抓取上。主线程添加任务后，调用notify触发阻塞的线程。

线程池需要一个线程类：WorkThread，其作用有：

提供线程的例程。创建线程WorkThread后，需要抓取任务，并执行任务。这是线程的例程。

线程池需要一个任务类：Task，其作用有：

提供线程抓取并执行的任务目标。

一个线程池包括四个基本部分：

https://www.cnblogs.com/wangyichuan/p/5967949.html
1 线程管理器(ThreadPool)：用于创建并管理线程池，包括创建线程、销毁线程池、添加新任务。

2 工作线程(PoolWorker)：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务。

3 任务接口(Task)：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口、任务执行 完后的收尾工作、任务的执行状态等。

4 任务队列(TaskQueue)：用于存放没有处理的任务，提供一种缓冲机制。

synchronized

synchronized用来修饰一个非静态方法，表示执行这个方法，必须获取该方法所属对象的锁； synchronized用来修饰静态方法，表示要执行该方法必须获取该类的类锁；synchronized修饰代码块synchronized(obj) { //code.... }表示执行该代码块必须获取obj这个对象的对象锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。

atomic action（原子操作）：

在Java中，以下两点操作是原子操作。

1)，对引用变量和除了long和double之外的原始数据类型变量进行读写。

2)，对所有声明为volatile的变量（包括long和double）的读写。
另外：在java.util.concurrent和java.util.concurrent.atomic包中提供了一些不依赖于同步机制的线程安全的类和方法。

有界、无界队列对ThreadPoolExcutor执行的

Java提供了4钟线程池：
newCachedThreadPool
newFixedThreadPool
newSingleThreadExecutor
newScheduledThreadPool

workQueue： 一个阻塞队列，用来存储等待执行的任务。 一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;    
LinkedBlockingQueue;    
SynchronousQueue  

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(  
                            1, //corePoolSize  
                            2,  //maximumPoolSize  
                            1L,  
                            TimeUnit.SECONDS,  
                            workQueue  
                            );

如何避免死锁？

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序（升序或降序）做操作来避免死锁

线程的状态和切换

https://blog.csdn.net/pange1991/article/details/53860651

  1. 新建(NEW)：新创建了一个线程对象。

  2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

  3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

  4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：
    (一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
    (二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
    (三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

  5. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

image.png

线程和进程

一、进程间的通信方式
管道( pipe )：
管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
有名管道 (namedpipe) ：
有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
信号量(semophore ) ：
信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
消息队列( messagequeue ) ：
消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
信号 (sinal ) ：
信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
共享内存(shared memory ) ：
共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
套接字(socket ) ：
套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同设备及其间的进程通信。

二、线程间的通信方式
锁机制：包括互斥锁、条件变量、读写锁
互斥锁提供了以排他方式防止数据结构被并发修改的方法。
读写锁允许多个线程同时读共享数据，而对写操作是互斥的。
条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。
信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量
信号机制(Signal)：类似进程间的信号处理

上一篇 下一篇

猜你喜欢

热点阅读