- 浏览: 53046 次
- 性别:
- 来自: 南京
最新评论
-
fellowming:
官网对这个死锁的原因是,S1申请X锁时,S2优先提出申请X锁, ...
MySQL InnoDB锁机制(一) -
zxjlwt:
学习了。不知道大侠有没有用过karaf。http://sure ...
OSGi中使用log4j -
908311595:
文章写的很好
Java网络安全(一) -
wang_janne:
574221240@qq.com 兄弟方便的话,给我个源码!万 ...
Apache xml-rpc与spring的整合 -
whbah:
whbah 写道我用的是felix容器,在windows下测试 ...
OSGi中使用log4j
Java多线程基础
1、实现线程的方式
在Java中线程的实现无外乎两种方法:实现Runnable接口、继承Thread类:
实现Runnable接口
继承Thread类
2、实现线程的变种方式
Java的线程的实现方式还有很多变种,但都是基于上面的两种 方式的。
使用内部类继承Thread类
使用匿名内部类
以上两个变种都是使用了Thread类,当然也可以使用Runnable接口,做法类似,在此就不举例子了。
3、Executors
Java1.5引入了一些新的类,方便了对线程的管理,先看下面的例子
在上面的例子中,并没有使用直接使用Thread类的start()方法执行线程,而是交给了Executor来管理线程的执行。
Executors.newCachedThreadPool()方法创建一个ExecutorService(一个Executor的实现),Executor会为每个需要执行的任务创建一个线程并执行它;当Executor的shutdown()方法被调用后,就不能再把任务提交给Executor了,否则会报java.util.concurrent.RejectedExecutionException异常。
除了CachedThreadPools,还有FixedThreadPools和SingleThreadExecutor。三者的区别非常简单,CachedThreadPools根据需要创建足够多的线程;FixedThreadPools在初始化的时候就创建好固定数目的线程;SingleThreadExecutor就像是大小为1的FixedThreadPools,同一时间只会有一个线程在执行。
从下面的例子就可以看出来当有多个任务提交给SingleThreadExecutor时,这些任务将按照提交的顺序一个一个的执行;同样的道理也适合FixedThreadPools。
输出结果
从结果可以看出,交给SingleThreadExecutor管理的任务都是串行执行的。
4、让线程像方法一样返回结果
线程,是某个任务的一次执行过程,从线程本身来看,它不应该像方法那样具有返回值。但是为了提高程序的灵活性,Java1.5提供了Callable接口,通过Callable接口,可以让线程返回一个值,看下面的例子:
输出结果
从输出结果中,可以看到每个线程的返回值"Result of X"都在main方法中取到并打印到控制台了。
使用Callable接口时,要注意以下几点:
5、线程的基础知识
Deamon(后台线程)
后台线程往往是在运行在后台,给程序提供某些服务的线程,它本身不算是程序的组成部分。所以,当虚拟机中只剩下后台线程时,程序也就自动结束了;但只要还有任何非后台线程在运行着,程序就不会结束。看下面的例子:
上面的程序不会有任何的输出,甚至连finally里面的内容也没有执行,因为线程t被设置成了后台线程,在它睡眠的1秒种时间里,main(非后台)线程已经结束了,这时虚拟机中只剩下后台进程,这样程序也自动结束了,因而看不到线程t的输出。
sleep & yield
sleep()方法让线程睡眠一段时间,时间过后,线程才会去争取cpu时间片。
Java1.5提供了一个新的TimeUnit枚举,让sleep的可读性更好。
yield()方法让线程主动让出cpu,让cpu重新调度以决定哪个线程可以使用cpu。
优先级
优先级,故名思意,决定了一个线程的重要程度。优先级高的线程并不一定总比优先级低的进程先得到处理,而只是机会高一些。
虽然java提供了10个优先级级别,但是由于各个平台对进程、线程优先级的定义各不相同,在程序中最好只用三个优先级别MAX_PRIORITY,NORM_PRIORITY,and MIN_PRIORITY。
join
如果一个线程访问了另一个线程的join()方法,那当前线程就会处于等待状态,直到另一个线程结束。例如:
结果输出
从输出可以看出,joiner在调用了sleeper.join方法后,就会一直等待,直到sleeper执行完了再继续执行。
6、线程的异常处理
通常情况下,我们会在run()方法里面进行异常处理。但是如果某些时候,需要在run()方法外面处理异常,该怎么办呢?先看下面的例子:
上面的程序并没有像预期那样输出caught,而是直接把异常抛给了控制台。那怎么样才能在run()方法外面处理异常呢?Java1.5提供了一个接口Thread.UncaughtExceptionHandler,只需要实现uncaughtException(Thread t, Throwable e)方法就可以达到我们的目的了,看下面的例子:
通过实现一个Thread.UncaughtExceptionHandler对象,就可以达到我们的目的了。
1、实现线程的方式
在Java中线程的实现无外乎两种方法:实现Runnable接口、继承Thread类:
实现Runnable接口
public class MyTask implements Runnable { @Override public void run() { System.out.println("mytask executed...."); } public static void main(String[] args) { Thread t = new Thread(new MyTask()); t.start(); System.out.println("main complete."); } }
继承Thread类
public class MyTask2 extends Thread { @Override public void run() { System.out.println("mytask2 executed...."); } public static void main(String[] args) { Thread t = new MyTask2(); t.start(); System.out.println("main complete."); } }
2、实现线程的变种方式
Java的线程的实现方式还有很多变种,但都是基于上面的两种 方式的。
使用内部类继承Thread类
public class InnerThread { private Inner inner; private class Inner extends Thread { @Override public void run() { System.out.println("inner task executed...."); } } public InnerThread() { inner = new Inner(); inner.start(); } public static void main(String[] args) { InnerThread i = new InnerThread(); System.out.println("main complete."); } }
使用匿名内部类
public class AnonymousThread { public AnonymousThread() { Thread t = new Thread(){ @Override public void run() { System.out.println("anonymous task executed...."); } }; t.start(); } public static void main(String[] args) { AnonymousThread i = new AnonymousThread(); System.out.println("main complete."); } }
以上两个变种都是使用了Thread类,当然也可以使用Runnable接口,做法类似,在此就不举例子了。
3、Executors
Java1.5引入了一些新的类,方便了对线程的管理,先看下面的例子
public class CachedThreadPool { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); for (int i=0; i<5; i++) { exec.execute(new MyTask()); } exec.shutdown(); System.out.println("main complete."); } } class MyTask implements Runnable { static int counter = 0; private final int id = counter++; @Override public void run() { System.out.println("task[" + id + "] executed...."); } }
在上面的例子中,并没有使用直接使用Thread类的start()方法执行线程,而是交给了Executor来管理线程的执行。
Executors.newCachedThreadPool()方法创建一个ExecutorService(一个Executor的实现),Executor会为每个需要执行的任务创建一个线程并执行它;当Executor的shutdown()方法被调用后,就不能再把任务提交给Executor了,否则会报java.util.concurrent.RejectedExecutionException异常。
除了CachedThreadPools,还有FixedThreadPools和SingleThreadExecutor。三者的区别非常简单,CachedThreadPools根据需要创建足够多的线程;FixedThreadPools在初始化的时候就创建好固定数目的线程;SingleThreadExecutor就像是大小为1的FixedThreadPools,同一时间只会有一个线程在执行。
从下面的例子就可以看出来当有多个任务提交给SingleThreadExecutor时,这些任务将按照提交的顺序一个一个的执行;同样的道理也适合FixedThreadPools。
public class CachedThreadPool { public static void main(String[] args) { ExecutorService exec = Executors.newSingleThreadExecutor(); for (int i=0; i<5; i++) { exec.execute(new MyTask()); } exec.shutdown(); System.out.println("main complete."); } } class MyTask implements Runnable { static int counter = 0; private final int id = counter++; @Override public void run() { System.out.println("task[" + id + "] started...."); Thread.currentThread().yield(); System.out.println("task[" + id + "] completed...."); } }
输出结果
task[0] started.... main complete. task[0] completed.... task[1] started.... task[1] completed.... task[2] started.... task[2] completed.... task[3] started.... task[3] completed.... task[4] started.... task[4] completed....
从结果可以看出,交给SingleThreadExecutor管理的任务都是串行执行的。
4、让线程像方法一样返回结果
线程,是某个任务的一次执行过程,从线程本身来看,它不应该像方法那样具有返回值。但是为了提高程序的灵活性,Java1.5提供了Callable接口,通过Callable接口,可以让线程返回一个值,看下面的例子:
public class CallableDemo { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); List<Future<String>> threadRlt = new ArrayList(); for(int i=0; i<5;i++) { threadRlt.add(exec.submit(new MyTask())); } for (Future<String> f : threadRlt) { try { System.out.println(f.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } } class MyTask implements Callable<String> { static int counter = 0; private final int id = counter++; @Override public String call() { System.out.println("task[" + id + "] started...."); Thread.currentThread().yield(); System.out.println("task[" + id + "] completed...."); return "Result of " + id; } }
输出结果
task[0] started.... task[1] started.... task[0] completed.... task[2] started.... task[1] completed.... task[3] started.... task[3] completed.... task[2] completed.... task[4] started.... Result of 0 Result of 1 Result of 2 Result of 3 task[4] completed.... Result of 4
从输出结果中,可以看到每个线程的返回值"Result of X"都在main方法中取到并打印到控制台了。
使用Callable接口时,要注意以下几点:
- 使用Callable时,要实现的是call()方法,而不是run()方法,并且call()方法是有一个返回值 的;
- 使用Callable的任务,只能通过Executor.submit()方法来执行,而不能像普通线程那样,通过Thread.start()来启动;
- Executor.submit()方法返回一个Future对象,通过Future对象的get()方法,可以拿到线程的返回值。如果线程还没有执行结束,那么get()方法会阻塞,一直到线程执行结束。在调用get()方法前,也可以通过isDone方法先判断线程是否已经执行结束。
5、线程的基础知识
Deamon(后台线程)
后台线程往往是在运行在后台,给程序提供某些服务的线程,它本身不算是程序的组成部分。所以,当虚拟机中只剩下后台线程时,程序也就自动结束了;但只要还有任何非后台线程在运行着,程序就不会结束。看下面的例子:
public class DaemonThreadDemo { public static void main(String[] args) { Thread t = new Thread() { @Override public void run() { try { TimeUnit.SECONDS.sleep(1); System.out.println("Can u see this?"); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println("Can reach here?"); } } }; t.setDaemon(true); t.start(); } }
上面的程序不会有任何的输出,甚至连finally里面的内容也没有执行,因为线程t被设置成了后台线程,在它睡眠的1秒种时间里,main(非后台)线程已经结束了,这时虚拟机中只剩下后台进程,这样程序也自动结束了,因而看不到线程t的输出。
sleep & yield
sleep()方法让线程睡眠一段时间,时间过后,线程才会去争取cpu时间片。
Java1.5提供了一个新的TimeUnit枚举,让sleep的可读性更好。
yield()方法让线程主动让出cpu,让cpu重新调度以决定哪个线程可以使用cpu。
优先级
优先级,故名思意,决定了一个线程的重要程度。优先级高的线程并不一定总比优先级低的进程先得到处理,而只是机会高一些。
虽然java提供了10个优先级级别,但是由于各个平台对进程、线程优先级的定义各不相同,在程序中最好只用三个优先级别MAX_PRIORITY,NORM_PRIORITY,and MIN_PRIORITY。
join
如果一个线程访问了另一个线程的join()方法,那当前线程就会处于等待状态,直到另一个线程结束。例如:
class Sleeper extends Thread { public Sleeper() { start(); } public void run() { try { sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("sleeper has awakened"); } } class Joiner extends Thread { private Sleeper sleeper; public Joiner(Sleeper sleeper) { this.sleeper = sleeper; start(); } public void run() { try { sleeper.join(); } catch (InterruptedException e) { System.out.println("Interrupted"); } System.out.println("joiner completed"); } } public class Joining { public static void main(String[] args) { Sleeper sleeper = new Sleeper(); Joiner joiner = new Joiner(sleeper); } }
结果输出
sleeper has awakened joiner completed
从输出可以看出,joiner在调用了sleeper.join方法后,就会一直等待,直到sleeper执行完了再继续执行。
6、线程的异常处理
通常情况下,我们会在run()方法里面进行异常处理。但是如果某些时候,需要在run()方法外面处理异常,该怎么办呢?先看下面的例子:
public class ExceptionThread implements Runnable { public void run() { throw new RuntimeException(); } public static void main(String[] args) { try { Thread t = new Thread(new ExceptionThread()); t.start(); } catch(RuntimeException e) { System.out.println("caught"); } } }
上面的程序并没有像预期那样输出caught,而是直接把异常抛给了控制台。那怎么样才能在run()方法外面处理异常呢?Java1.5提供了一个接口Thread.UncaughtExceptionHandler,只需要实现uncaughtException(Thread t, Throwable e)方法就可以达到我们的目的了,看下面的例子:
public class ExceptionThread implements Runnable { public void run() { throw new RuntimeException(); } public static void main(String[] args) { Thread t = new Thread(new ExceptionThread()); t.setDefaultUncaughtExceptionHandler(new MyHandler()); t.start(); } } class MyHandler implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread arg0, Throwable arg1) { System.out.println("caught"); } }
通过实现一个Thread.UncaughtExceptionHandler对象,就可以达到我们的目的了。
评论
4 楼
冬天秋天
2011-11-29
没有注意到java5的新特新,学习了。
3 楼
fd_zhaoshuo
2011-11-15
写的挺好的
2 楼
koubai
2011-11-14
very well
1 楼
Technoboy
2011-11-14
发表评论
-
spring security 访问权限
2014-07-17 17:20 0package com.personal.oyl.newff ... -
spring mvc 返回json
2014-07-10 11:54 01. pom里面加上 <dependency ... -
OSGi中使用log4j
2012-01-04 17:20 6547最近在看关于OSGi方面的内容,自己做了些简单的例子。虽然在l ... -
Java网络安全(一)
2011-12-05 09:26 4459消息摘要是数据信息的数字指纹。通过某种安全散列算法(如SH ... -
JAVA多线程(四)
2011-11-29 11:35 1468死锁 1、何为死锁 简单说来,死锁就是系统中的线程因相互等 ... -
JAVA多线程(三)
2011-11-28 15:23 1340线程同步 1、什么是线程同步 概念上的东西在这里就不过多介 ... -
JAVA多线程(二)
2011-11-20 15:05 2241资源竞争 (线程互斥) 1、什么是资源竞争 有这样一种资源 ... -
JAVA初始化
2011-11-10 15:15 1017在JAVA中变量在使用 ... -
Apache xml-rpc与spring的整合
2011-10-23 18:45 4953之前在项目中使用了Apache xml-rpc,遇到了一个 ... -
Struts2的OGNL
2009-02-13 21:55 2508OGNL的全称是Object Graph Navigatio ...
相关推荐
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...
Java多线程读大文件 java多线程写文件:多线程往队列中写入数据
java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题
一个java 多线程操作数据库应用程序!!!
详细的讲解了java多线程的原理,并配有代码进行实战,适合java初学者和想对多线程有进一步了解的人。
java多线程经典案例,线程同步、线程通信、线程阻塞等经典案例
多线程启动.java多线程启动.java多线程启动.java多线程启动.java
java多线程并发查询数据库,使用线程池控制分页,并发查询。
该文档总结了Java多线程相关的知识点,分享给大家,简单易懂!
java多线程处理数据库数据,使用并发包,无框架,可批量处数据库数据,进行增删改。。等等操作。
资深Java专家10年经验总结,全程案例式讲解,首本全面介绍Java多线程编程技术的专著 结合大量实例,全面讲解Java多线程编程中的并发访问、线程间通信、锁等最难突破的核心技术与应用实践 Java多线程无处不在,如...
现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 线程是指进程中的一个执行流程,一个进程中可以运行多个线程。...本文档提供Java多线程编程经验,方便广大Java爱好者研究学习Java多线程
java多线程进度条
java多线程处理大数据,可根据配置的线程数,任务去调度处理
一张图方便理解和掌握java 多线程之间通信的实质 java 多线程 其实就是每个线程都拥有自己的内存空间,多线程之间的通信,比例A线程修改了主内存(main方法的线程)变量,需要把A线程修改的结果同步到主线程中,...
java多线程,对多线程,线程池进行封装,方便使用
Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程,另有A,B,C三个线程用不同的时间跑完。
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化,即在一块芯片上集成多个处理器内核(Core),多核处理器(Multicore Processor)离我们越来越近了――如今...
java多线程实现大批量数据切分成指定份数的数据,然后多线程处理入库或者导出,线程的个数和每份数据的数量都可以控制
java多线程并发的在新窗口