JAVA多线程及线程池

于 2020-02-10 16:11:55 发布
阅读量277 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： IT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/whatkevin1984/article/details/103714852

多线程

在这里插入图片描述
在这里插入图片描述
参考文档:https://blog.youkuaiyun.com/qq_41701956/article/details/84861232

继承Thread类:

package javatest;


class SubThread extends Thread{
	public void run(){
		for(int i=0; i<100; i++) {
			System.out.println(Thread.currentThread().getName() + ": " +i);
		}
	}
}
public class testThread {
	public static void main(String[] args){
		
		SubThread st1 = new SubThread();
		st1.start();
		
		SubThread st2 = new SubThread();
		st2.start();
		
		for(int i=0; i<100; i++) {
			System.out.println(Thread.currentThread().getName() + ": " + i);
		}
	}

}

实现Runnable接口:

package javatest;

class PrintNum implements Runnable{
	public void run(){
		for(int i=0; i<100; i++) {
			System.out.println(Thread.currentThread().getName() + ": " +i);
		}
	}
	
}

public class testRunnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		PrintNum p = new PrintNum();
		Thread t1 = new Thread(p);
		t1.start();
		Thread t2 = new Thread(p);
		t2.start();

	}

}

sychornized同步代码块:

package javatest;

class ticket implements Runnable {
	int ticket = 100;
	Object obj = new Object();

	public void run() {
		while (true) {
			synchronized (obj) {
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + ": " + ticket--);
				} else
					break;
			}
		}
	}
}

public class testsysn {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ticket p = new ticket();
		Thread t1 = new Thread(p);
		t1.start();
		Thread t2 = new Thread(p);
		t2.start();

	}

}

sychronized同步方法:

package javatest;

class ticket2 implements Runnable {
	int ticket = 100;

	public void run() {
		while (true) {
		show();
		}
	}
	
	public synchronized void show(){
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + ": " + ticket--);
		} 
		
	}
}

public class testsysn2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		ticket2 p = new ticket2();
		Thread t1 = new Thread(p);
		t1.start();
		Thread t2 = new Thread(p);
		t2.start();

	}

}

线程池

线程池的优势
（1）、降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
（2）、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
（3）方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。
（4）提供更强大的功能，延时定时线程池。

Java5提供5种类型的线程池，分别如下：

1.newFixedThreadPool-固定大小的线程池
(1) newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程；
(2) 其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子；
(3) 和cacheThreadPool不同，FixedThreadPool没有IDLE机制(可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的)，所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器；
(4) 从方法的源代码看，cache池和fixed池调用的是同一个底层池，只不过参数不同:
fixed池线程数固定，并且是0秒IDLE(无IDLE)；
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力)，60秒IDLE。

a. 使用系统提供的线程池类型(推荐)

package javatest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolPratice {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//创建一个'可重用固定线程数'的线程池
		ExecutorService pool = Executors.newFixedThreadPool(3);
		//创建线程对象
		PrintNumber pn = new PrintNumber();
		Thread t1 = new Thread(pn);
		Thread t2 = new Thread(pn);
		Thread t3 = new Thread(pn);
		Thread t4 = new Thread(pn);
		//将线程放入池中执行
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		//关闭线程池
		pool.shutdown();
	}

}

class PrintNumber implements Runnable{
	public void run(){
		for(int i=0; i<100; i++) {
			System.out.println(Thread.currentThread().getName() + ": " +i);
		}
	}
	
}

b. 自定义线程池

package javatest;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolPratice3 {
    public static void main(String[] args) {
        ThreadPoolExecutor pool=new ThreadPoolExecutor(5,10,200, TimeUnit.MILLISECONDS,  new ArrayBlockingQueue<Runnable>(5));
        for(int i=0;i<15;i++) {
            Task task=new Task(i);
            pool.execute(task);
            System.out.println("线程池中线程数目："+pool.getPoolSize()+"，队列中等待执行的任务数目："+
                     pool.getQueue().size()+"，已执行玩别的任务数目："+pool.getCompletedTaskCount());
        }
        pool.shutdown();
    }
}

class Task implements Runnable{
      private int num;
      public Task(int num) {
          this.num=num;
      }
    @Override
    public void run() {
        System.out.println("正在执行任务  "+num);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程"+num+"执行完毕");
    }
}

2.newCachedThreadPool-可变尺寸的线程池(缓存线程池)
(1) 缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse(重用)，如果没有，就建立一个新的线程加入池中；
(2) 缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多；
(3) 能reuse(重用)的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s，超过这个IDLE时长，线程实例将被终止及移出池；
(4) 注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。

3.ScheduledThreadPool-调度线程池
(1) 调度型线程池；
(2) 这个池子里的线程可以按schedule依次delay执行，或周期执行。

4.SingleThreadExecutor-单例线程池
(1) 单例线程，任意时间池中只能有一个线程；
(2) 用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE(无IDLE)。

5.自定义线程池–ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

参数：
corePoolSize :
核心线程数，核心线程会一直存活，即使没有任务需要处理。当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。
核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

maximumPoolSize:
当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池会拒绝处理任务而抛出异常。

keepAliveTime :
当线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。

unit :
keepAliveTime 参数的时间单位。

workQueue :
执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

threadFactory:
线程工厂，用来创建线程，一般有四种选择策略。

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。

LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。

PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。

SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

handler:
拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略，四种策略为
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

抛出：
IllegalArgumentException - 如果corePoolSize或keepAliveTime小于零，或者maximumPoolSize小于或等于零，或者corePoolSize 大于maximumPoolSize。
NullPointerException - 如果workQueue为null

在这里插入图片描述
总结：

  • 如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

  • 如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；

  • 如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理； 如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；

  • 如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

Java内存模型JMM(Java Memory Model)

区别于JVM的内存模型，堆、栈、工作区
Java 内存模型来屏蔽掉各种硬件和操作系统的内存差异，达到跨平台的内存访问效果。JLS(Java语言规范)定义了一个统一的内存管理模型JMM(Java Memory Model)

Java内存模型规定了所有的变量都存储在主内存中，此处的主内存仅仅是虚拟机内存的一部分，而虚拟机内存也仅仅
是计算机物理内存的一部分（为虚拟机进程分配的那一部分）。

Java内存模型分为主内存，和工作内存。主内存是所有的线程所共享的，工作内存是每个线程自己有一个，不是共享的。

每条线程还有自己的工作内存，线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝。线程对变量的所有操作（读取、赋值），都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成，线程、主内存、工作内存三者之间的交互关系如

下图：
在这里插入图片描述
Java内存间交互操作

JLS定义了线程对主存的操作指令：lock，unlock，read，load，use，assign，store，write。这些行为是不可分解的原子操作，在使用上相互依赖，read-load从主内存复制变量到当前工作内存，use-assign执行代码改变共享变量值，store-write用工作内存数据刷新主存相关内容。

lock：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
unlock：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

多线程的三个特性

1、原子性（Atomicity）
　　原子性是指一个原子操作在cpu中不可以暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。原子操作保证了原子性问题。

x++（包含三个原子操作）a.将变量x 值取出放在寄存器中 b.将将寄存器中的值+1 c.将寄存器中的值赋值给x

由Java内存模型来直接保证的原子性变量操作包括read、load、use、assign、store和write六个，大致可以认为基础数据类型的访问和读写是具备原子性的。如果应用场景需要一个更大范围的原子性保证，Java内存模型还提供了lock和unlock操作来满足这种需求，尽管虚拟机未把lock与unlock操作直接开放给用户使用，但是却提供了更高层次的字节码指令monitorenter和monitorexit来隐匿地使用这两个操作，这两个字节码指令反映到Java代码中就是同步块——synchronized关键字，因此在synchronized块之间的操作也具备原子性。

2、可见性(Visibility)

java 内存模型的主内存和工作内存，解决了可见性问题。

volatile赋予了变量可见——禁止编译器对成员变量进行优化，它修饰的成员变量在每次被线程访问时，都强迫从内存中重读该成员变量的值；而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存，这样在任何时刻两个不同线程总是看到某一成员变量的同一个值，这就是保证了可见性。

可见性就是指当一个线程修改了线程共享变量的值，其它线程能够立即得知这个修改。无论是普通变量还是volatile变量都是如此，普通变量与volatile变量的区别是volatile的特殊规则保证了新值能立即同步到主内存，以及每使用前立即从内存刷新。因为我们可以说volatile保证了线程操作时变量的可见性，而普通变量则不能保证这一点。

3、有序性(Ordering)

Java内存模型中的程序天然有序性可以总结为一句话：如果在本线程内观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有操作都是无序的。前半句是指“线程内表现为串行语义”，后半句是指“指令重排序”现象和“工作内存主主内存同步延迟”现象。

线程状态

新建状态（New）：新创建了一个线程对象。
就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
在这里插入图片描述

多线程安全

关键字

volatile

volatile修饰的变量变化过程：
第一：使用volatile关键字会强制将修改的值立即写入主存；
第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量的缓存行无效；
第三：由于线程1的工作内存中缓存变量的缓存行无效，所以线程1再次读取变量的值时会去主存读取。
可见性和原子性：
可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。

ThreadLocal

ThreadLocal不是为了解决多线程访问共享变量，而是为每个线程创建一个单独的变量副本，提供了保持对象的方法和避免参数传递的复杂性。

顾名思义它是local variable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。(ThreadLocal采用了“以空间换时间”的方式)

join

join()方法的作用，是等待这个线程结束；
也就是说，t.join()方法阻塞调用此方法的线程(calling thread)进入 TIMED_WAITING 状态，直到线程t完成，此线程再继续；
通常用于在main()主线程内，等待其它线程完成再结束main()主线程。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值