1:后台线程(守护线程)
后台线程一半用来提供一种通用服务,不属于程序中不可或缺的部分。所有的非后台线程结束时,进程会杀死所有的后台线程。后台进程在不执行finally方法的情况下就有可能结束run方法
public class SimpleDaemos implements Runnable {
public static void main(String[] args) throws InterruptedException {
for(int i=0;i<10;i++) {
Thread daemo = new Thread(new SimpleDaemos());
daemo.setDaemon(true);
daemo.start();
}
System.out.println("All daemo started");
TimeUnit.MILLISECONDS.sleep(175);
}
public void run() {
try {
while(true) {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
}
} catch (InterruptedException e) {
System.out.println("sleep() interrupted");
}
}
}
2:ThreadFactory定制线程属性
public class DaemonFromFactory implements Runnable{
public static void main(String[] args) throws InterruptedException {
//使用一个线程工厂作为参数,创建的线程具有线程工厂的属性
ExecutorService exe = Executors.newCachedThreadPool(new DaemoThreadFactory());
for(int i=0;i<10;i++) {
exe.execute(new DaemonFromFactory());
}
System.out.println("All daemos started");
TimeUnit.MILLISECONDS.sleep(500);
}
public void run() {
}
}
/**
* 使用线程工厂创建出来的线程全部是守护线程
* @author zhuchangxin
*
*/
class DaemoThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
3:join()加入一个线程
在a线程上调用b.join()。则a线程等待b执行完,然后才继续执行。如果期间调用interrupt()方法打断线程,则b线程被打断,a继续向下执行
public class Joining {
public static void main(String[] args) throws InterruptedException {
Sleeper sleepy = new Sleeper("Sleepy" , 1500);// 1
Sleeper grumpy = new Sleeper("Grumpy" , 1500);// 2
Joiner dopey = new Joiner("Dopey", sleepy);// 3
Joiner doc = new Joiner("Doc", grumpy);// 4
Thread.sleep(500);
grumpy.interrupt();
}
}
class Sleeper extends Thread {
private int duration;
public Sleeper(String name,int sleepTime) {
super(name);
this.duration = sleepTime;
start();
}
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(duration);// 5
} catch (InterruptedException e) {
//调用Thread父类中的getName方法
System.out.println(getName() + " was interrupted. isInterrupted(): " + isInterrupted());
return ;
}
System.out.println(getName() + " has awakened");
}
}
class Joiner extends Thread {
private Sleeper sleeper;
public Joiner(String name,Sleeper sleeper) {
super(name);
this.sleeper = sleeper;
start();
}
public void run() {
try {
sleeper.join();
}catch (InterruptedException e) {
System.out.println("Interrupted");
}
System.out.println(getName() + " join completed");
}
}
输入结果:
Grumpy was interrupted. isInterrupted(): false
Doc join completed
Sleepy has awakened
Dopey join completed
4:捕获异常
我们无法捕获从线程中逃逸的异常,一旦异常逃出run方法,它将会向控制台输出,即便使用将main主体放到try,catch中
public class SimpleDaemos implements Runnable {
public static void main(String[] args) {
try {
for(int i=0;i<10;i++) {
Thread daemo = new Thread(new SimpleDaemos());
daemo.setDaemon(true);//设成守护线程
daemo.start();
}
System.out.println("All daemo started");
TimeUnit.MILLISECONDS.sleep(175);
} catch(Exception e) {
}
}
public void run() {
try {
throw new InterruptedException();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
控制台仍会输出异常
解决方法:可以Thread.UncaughtExceptionHandler接口,该接口在线程因未捕获的异常临近死亡时调用
public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool(new HandlerThreadFactory());
exe.execute(new ExceptionThread2());
}
}
class ExceptionThread2 implements Runnable {
@Override
public void run() {
Thread t = Thread.currentThread();
System.out.println("run() by " + t);
System.out.println("eh = " + t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}
//创建一个线程工厂,由该工厂创建的线程使用自定义异常类作为默认的异常处理方法
class HandlerThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("eh = " + t.getUncaughtExceptionHandler());
return t;
}
}
//自定义异常类
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("caught " + e);
}
}
分享到:
相关推荐
多线程和高并发二.md
并发二:原子性、可见性、有序性
C ++中并发二进制搜索树的性能比较 该项目旨在比较C ++中二进制搜索树的几种并发实现: 跳过清单 非阻塞二叉搜索树 乐观的AVL树 无锁多路搜索树 基于计数器的树 注意:该代码仅在Intel处理器上经过测试。 与其他...
《实战Java高并发程序设计》 第二版随书代码
步骤二:调整 IIS 的 AppConcurrentRequestLimit IIS 的 AppConcurrentRequestLimit 是指同时处理的请求数量的限制。默认情况下,IIS 的 AppConcurrentRequestLimit 为 5000,需要将其调整到 100000。可以通过输入...
二、选择的典型页面及并发点 1、登录首页http://192.168.1.10。并发点:同时打开这个链接。 2、打开页面http://192.168.1.10,点击页面上的“市场准入”。 并发点:同时点击“市场准入”链接。 3、打开市场准入页面...
java并发编程pdf文档第二部分:Java并发编程实战.pdf、Java多线程编程核心技术.pdf、实战Java高并发程序设计.pdf
java并发编程总结,为xmind格式,总结的很详细,包含常见的并发容器,锁等知识
│ 高并发编程第二阶段23讲、第二阶段课程答疑学员问题.mp4 │ 高并发编程第二阶段24讲、Guarded Suspension设计模式-上.mp4 │ 高并发编程第二阶段25讲、Guarded Suspension设计模式-下.mp4 │ 高并发编程第二...
2. 聊聊并发(二)Java SE1.6中的Synchronized 3. 聊聊并发(三)Java线程池的分析和使用 4. 聊聊并发(四)深入分析ConcurrentHashMap 5. 聊聊并发(五)原子操作的实现原理 6. 聊聊并发(六)...
JAVA并发编程艺术 高清pdf : 1.并发变成的挑战 2. java并发机制的底层实现原理 3. java 内存模型 4. java并发编程基础 5.java中的锁。。。。。。。
第二部分 结构化并发应用程序 第6章 任务执行 6.1 在线程中执行任务 6.1.1 串行地执行任务 6.1.2 显式地为任务创建线程 6.1.3 无限制创建线程的不足 6.2 Executor框架 6.2.1 示例:基于Executor的Web服务器 ...
Java并发编程:设计原则与模式(第二版).pdf
Java并发编程:设计原则与模式(第二版)
│ 高并发编程第二阶段23讲、第二阶段课程答疑学员问题.mp4 │ 高并发编程第二阶段24讲、Guarded Suspension设计模式-上.mp4 │ 高并发编程第二阶段25讲、Guarded Suspension设计模式-下.mp4 │ 高并发编程第二...
二、CountDownLatch CountDownLatch 是一种同步工具,允许一个或多个线程一直等待,直到其他线程完成操作。它的作用是允许 1 或 N 个线程等待其他线程完成执行。CountDownLatch 的实现是通过一个计数器来实现的,当...
java 并发编程的艺术pdf清晰完整版 源码
java 并发变成设计原则与模式第二版 PDF版本,下载即看
第二部分讨论了如何构建并发应用程序,涉及任务分解、线程池的高级特性,以及如何提高图形用户界面(GUI)的响应性。这部分内容强调了并发应用的设计和行为控制,包括任务的取消和关闭机制。 第三部分聚焦于性能...
二、解决并发问题的方法 1. 使用锁(synchronized) Java 提供了 synchronized 关键字来对对象加锁。加锁的对象将被锁定,其他线程必须等待当前线程释放锁后才能访问该对象。有三种方式使用 synchronized: * 锁...