多线程总结

flylynne

浏览: 373566 次
性别:
来自: 上海

最近访客更多访客>>

chengpeng_2015

WangJiaX

dy.f

fwgforce

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

JAVA

多线程 JVM thread OS 虚拟机

线程是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

线程的一些特性：

所有的Java代码都是在某个线程中执行的，所以在任一行Java代码中使用Thread.currentThread()都可以得到当前运行线程。
JVM允许多个线程并发执行，虽然同一时刻只能有一个线程占用CPU，但每个线程占有的时间片非常短，所以人类的感官上多个线程是并发执行的。
当 JVM启动时，至少有一个用户线程运行，即执行某个类的main方法的线程。

线程在下列情况之一终止运行：

Thread.run方法运行完毕(或者是Thread包含的Runnable对象的run方法执行完毕)
run方法内的代码运行时发生异常。

创建线程：

继承Thread类，覆盖run方法
实现Runnable接口，通过Thread类的带Runnable参数的构造函数传入到Thread对象内,一种常用的方式：
Java代码
1. Thread t=new Thread(new Runable(){
2. public void run(){
3. //do something
4. }
5. });
```
Thread t=new Thread(new Runable(){
  public void run(){
     //do something
  } 
});
```

运行线程：

调用Thread的start方法，调用之后，JVM启动一个新的线程，在新线程中执行该线程对象的run方法。
线程启动之后，不能再调用start方法，否则会抛出IllegalThreadStateException

线程的一些自动继承的特性：

如果未指明优先级，则被创建的线程和创建它的线程具有相同优先级。
如果未指明ThreadGroup，则被创建的线程和创建它的线程使用相同的ThreadGroup。如果指定ThreadGroup为null,则系统会自动将本线程加入系统级的ThreadGroup。所以说不存在没有ThreadGroup的线程。
如果未指明是否守护线程，则被创建的线程和创建它的线程具有相同的daemon属性。也就是说守护线程创建的线程如果未特别指定，则是守护线程，用户线程创建的线程如果未特别指定，则是用户线程。main线程是用户线程，除非被Thread.currentThread().setDaemon(true)方式改变。

线程优先级：

线程优先级范围是1-10，1最低优先级10最高优先级。
优先级越高越先被JVM从“等待运行”（waiting-to-run）的状态挑选出来运行。
JVM线程和操作系统线程的关系有2种（甚至可能是3种,依赖于平台和JVM实现）：
1. n-1关系，所有JVM线程都在同一个OS线程中运行。
2. n-m关系，一个JVM线程是可以在多个OS线程中运行，一个OS线程可运行多个JVM线程，不管硬件是多核还是单核。
3. 1-1关系，一个JVM线程对应一条OS进程。（早期JVM的在Linux上的实现版本）

所以，线程的优先级设置是不可靠的，依赖于JVM实现和OS。.NET线程5个等级:Highest,AboveNormal,Normal,BelowNormal,Lowest.Solaris有15个等级，最高的5个等级是给进程中断层级（Process Interrupt Levels ，PILs）使用。也就是说PIL可以中断普通进程知道执行直到其运行结束。剩下的10个优先级可以被线程使用。所以优先级8和9可能并没有区别。默认优先级是5，最大优先级由所在ThreadGroup的maxPriority决定。也就是说所属ThreadGroup最大优先级是8则，以构造函数Thread(ThreadGroup g,String name)所创建的线程即使将其设置为10，优先级仍然是8.

当等待运行的线程中有3种优先级相差比较大的线程在运行的时候，单任务操作系统会按高-中-低的顺序来执行线程，也就是说先跑完所有高等级的再跑低等级的，多任务操作系统则会间歇执行，但不保证高优先级的、相同任务内容的任务会更快完成，即使你让线程跑上10分钟。非常诡异，可能跟CPU是双核有关（但用3个优先级且混合启动线程还是有可能高优先级的跑输给低优先级的，哪怕是最高10和最低1）。给出代码，请读者分别在Linux和Windows下测试，有条件的话在Solaris上也试试。给个报告出来。

public static void main(String[] args) throws Exception {
int x=211;//210个线程分3组，每组70个，第211是“发令枪”
int n=0;//a类线程数量，本类线程优先级最高
int m=0;//b类线程数量，本类线程优先级最低
int l=0;//c类线程数量，本类线程优先级中间（5）
final CyclicBarrier cb=new CyclicBarrier(x);//发令枪类，让所有线程理论上在同一起跑线（也许和逐个逐个start没区别）
final List ln=new ArrayList(7);//存放a类线程的列表，为了在匿名类中可见，定义为final,7原本是21个线程在跑，后来为了理论上消除误差，增加到70个，此处没有修改过来。
final List lm=new ArrayList(7);//存放b类线程的列表
final List ll=new ArrayList(7);//存放c类线程的列表
for(int i=0;i<x-1;i++){//为了避免线程在创建的时候同类线程扎堆（理论上可能）产生误差，打乱创建过程。为了避免2组线程分别在双核CPU上各自单核上运行，采用了3组线程。
Runner t=null;
if(i%3==0){
t=new Runner(cb,"a"+i);
t.setPriority(8);//可以用10，但测试结果看不出区别。
ln.add(t);
n++;
}else if(i%3==1){
t=new Runner(cb,"b"+i);
t.setPriority(2);//可以用1，
lm.add(t);
m++;
}else{
t=new Runner(cb,"c"+i);
t.setPriority(5);
ll.add(t);
l++;
}
t.start();//不是真的启动线程哦。请看Runner类
}
System.out.println(n);//检验是不是每组70个。
System.out.println(m);
System.out.println(l);
try {
Thread.sleep(3000);//本意是为了让Runner在起跑线都预备好，在此停3秒。减少误差。
Timer timer =new Timer(true);//定时打印结果的线程。
timer.scheduleAtFixedRate(new TimerTask(){
@Override
public void run() {//定时打印每组线程的结果的平均值，由于打印是有先后顺序的，所以使用平均值，消除时间差（用心良苦啊。。。）
System.out.println("a avg--"+getAvg(ln));//可以将a组的结果放在最后，结果通常还是a最慢
System.out.println("b avg--"+getAvg(lm));
System.out.println("c avg--"+getAvg(ll));
}
}, 3000, 3000);//3秒打印一次。
cb.await();//发令枪响。
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("started ");
}
public static BigInteger getAvg(List l){//为什么用大整数？因为long,和int我都试过得不到想要的结果。
BigInteger total=BigInteger.valueOf(0);
for (Iterator iter = l.iterator(); iter.hasNext();) {
Runner r = (Runner) iter.next();
total=total.add(r.getCountPerMs());
}
return total.divide(BigInteger.valueOf(l.size()));//同组线程的结果的平均值
}
static class Runner extends Thread{//有心人可以试试改成只实现Runnable接口
private CyclicBarrier cb;
private String name;
private BigInteger count=BigInteger.valueOf(0);
private long startTime;
public Runner(CyclicBarrier cb,String name){
this.cb=cb;
this.name=name;
}
public void run(){
try {
cb.await();//让其在起跑线上等待其他线程和发令枪声
System.out.println(this.name+"start");//看看各个线程真正跑起来是否一致，不怕，每组有70条，一条拖后退问题不大，只要运行时间够长，体力好的应该还是不会输在起跑线的。
startTime=System.currentTimeMillis();//原本是为了消除时间差使用的，效果不好，改用发令枪，留着成了僵尸代码
for (;;) {
count=count.add(BigInteger.valueOf(1));
Thread.sleep(1);//调试手段，为了使线程慢跑，可以去掉对比结果。
// if(count%10000==0){
// Thread.yield();//调试手段，效果不明显，也毙掉了。
// }
// if(count.mod(m)==0){
// String info = name+":"+(count/100000)+"--"+this.getPriority()+"-"+this.isDaemon();
//// System.out.println(info);//早期调试手段，毙掉。
// }
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
public BigInteger getCountPerMs(){
// long value=System.currentTimeMillis()-startTime;
//// System.out.println(value);
//// System.out.println("count "+this.count);
// if(value==0)return BigInteger.valueOf(0);
// return this.count.divide(BigInteger.valueOf(value));
//以上一大段注释掉的代码原本是为了消除时间差的。没啥效果，毙掉
return this.count;
}
}

	public static void main(String[] args) throws Exception {
		int x=211;//210个线程分3组，每组70个，第211是“发令枪”
		int n=0;//a类线程数量，本类线程优先级最高
		int m=0;//b类线程数量，本类线程优先级最低
		int l=0;//c类线程数量，本类线程优先级中间（5）
		
		final CyclicBarrier cb=new CyclicBarrier(x);//发令枪类，让所有线程理论上在同一起跑线（也许和逐个逐个start没区别）
		final List ln=new ArrayList(7);//存放a类线程的列表，为了在匿名类中可见，定义为final,7原本是21个线程在跑，后来为了理论上消除误差，增加到70个，此处没有修改过来。
		final List lm=new ArrayList(7);//存放b类线程的列表
		final List ll=new ArrayList(7);//存放c类线程的列表
		for(int i=0;i<x-1;i++){//为了避免线程在创建的时候同类线程扎堆（理论上可能）产生误差，打乱创建过程。为了避免2组线程分别在双核CPU上各自单核上运行，采用了3组线程。
			Runner t=null;
			if(i%3==0){
				t=new Runner(cb,"a"+i);
				t.setPriority(8);//可以用10，但测试结果看不出区别。
				ln.add(t);
				n++;
			}else if(i%3==1){
				t=new Runner(cb,"b"+i);
				t.setPriority(2);//可以用1，
				lm.add(t);
				m++;
			}else{
				t=new Runner(cb,"c"+i);
				t.setPriority(5);
				ll.add(t);
				l++;
			}
			t.start();//不是真的启动线程哦。请看Runner类
		}
		System.out.println(n);//检验是不是每组70个。
		System.out.println(m);
		System.out.println(l);
		
		try {
			Thread.sleep(3000);//本意是为了让Runner在起跑线都预备好，在此停3秒。减少误差。
			Timer timer =new Timer(true);//定时打印结果的线程。
			timer.scheduleAtFixedRate(new TimerTask(){

				@Override
				public void run() {//定时打印每组线程的结果的平均值，由于打印是有先后顺序的，所以使用平均值，消除时间差（用心良苦啊。。。）
					System.out.println("a avg--"+getAvg(ln));//可以将a组的结果放在最后，结果通常还是a最慢
					System.out.println("b avg--"+getAvg(lm));
					System.out.println("c avg--"+getAvg(ll));
				}
				
				
			}, 3000, 3000);//3秒打印一次。
			cb.await();//发令枪响。
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("started ");
		
		
	}
	
	
	public static BigInteger getAvg(List l){//为什么用大整数？因为long,和int我都试过得不到想要的结果。
		BigInteger total=BigInteger.valueOf(0);
		for (Iterator iter = l.iterator(); iter.hasNext();) {
			Runner r = (Runner) iter.next();
			total=total.add(r.getCountPerMs());
		}
		return total.divide(BigInteger.valueOf(l.size()));//同组线程的结果的平均值
	}
	
	static class Runner extends Thread{//有心人可以试试改成只实现Runnable接口
		private CyclicBarrier cb;
		private String name;
		private BigInteger count=BigInteger.valueOf(0);
		private long startTime;
		public Runner(CyclicBarrier cb,String name){
			this.cb=cb;
			this.name=name;
		}
		public void run(){
			try {
				cb.await();//让其在起跑线上等待其他线程和发令枪声
				System.out.println(this.name+"start");//看看各个线程真正跑起来是否一致，不怕，每组有70条，一条拖后退问题不大，只要运行时间够长，体力好的应该还是不会输在起跑线的。
				
				startTime=System.currentTimeMillis();//原本是为了消除时间差使用的，效果不好，改用发令枪，留着成了僵尸代码
				for (;;) {
					count=count.add(BigInteger.valueOf(1));
					Thread.sleep(1);//调试手段，为了使线程慢跑，可以去掉对比结果。
//					if(count%10000==0){
//						Thread.yield();//调试手段，效果不明显，也毙掉了。
//					}
//					if(count.mod(m)==0){
//						String info = name+":"+(count/100000)+"--"+this.getPriority()+"-"+this.isDaemon();
////						System.out.println(info);//早期调试手段，毙掉。
//					}
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				e.printStackTrace();
			}
			 
		}
		public BigInteger getCountPerMs(){
//			long value=System.currentTimeMillis()-startTime;
////			System.out.println(value);
////			System.out.println("count "+this.count);
//			if(value==0)return BigInteger.valueOf(0);
//			return this.count.divide(BigInteger.valueOf(value));
//以上一大段注释掉的代码原本是为了消除时间差的。没啥效果，毙掉
			return this.count;
		}
	}

1. 加锁问题。

a)Java对象都有一个隐式的monitor锁，我们通常所说的获得某一个对象的锁就是指这个monitor。对于wait和notify还有notifyall方法，我们必须首先获得你要notify/wait的对象锁，然后调用才能成功，否则不获得锁直接wait/notify会报错的。

举个例子：
public static String lock = "lock"
synchronized (lock) {
try {
System.out.println(Thread.currentThread().getName()
+ " is waiting...");
lock.wait();
System.out.println(Thread.currentThread().getName()
+ " finished waiting...");
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()
+ " is interrupted");
}
}

我们通过synchronized获得lock对象上的锁，当获得锁成功以后我们通过调用lock.wait()方法(注意：这句子的意思不是让lock在wait，意思是当前的调用线程在lock对象上wait，其实就是把自己加入到lock对象的wait set里面)，然后使自己进入阻塞状态并且释放锁(这是和sleep方法的一个很大的区别！sleep方法是不会释放锁的，wait方法虽然也是阻塞但是释放锁)。

b)关于interrupt,对于一个线程来说它会不停的检查自己的interrupt置位状态，但是当它处于阻塞状态的时候它就无法检查该置位了，这也是要抛出InterruptedException的原因。即如果你对一个正在wait的线程进行Interrupt会抛出InterruptedException。

c)那我们如何唤醒wait线程呢？通过notify方法和notifyall方法，当然我们还是需要通过synchronized来获得lock对象的monitor锁，然后对其进行notify。notify方法会随机在lock对象上的wait set里随机挑出来一个线程进行notify；notifyall方法是将该wait set的所有线程都notify了。当一个线程被notify以后，它会自动重新获得该对象的对象锁，获得成功后它会继续执行wait方法后面的代码。当所有代码都执行完毕，它会推出synchronized块，同时释放锁。注意：因为notify后的线程还是会试图获取锁，所以最好我们使用notifyall，因为很可能我们随机挑选的线程被notify以后尝试获取锁失败它还是会block，这样很可能造成死锁，因为唯一被唤醒的线程也block了。

d)现在我们对这种显示给一个对象加锁的情况了解了，那么对于这种public synchronized void test(){}方法jvm是怎么处理的呢？在这种情况下，我们其实是在获取当前调用实例的锁，比如我们有Demo demo = new Demo()，然后我们demo.test()就是获得demo对象上的锁。

e)另外一种情况public static synchronized void test(){};这样static方法是不能被instance访问的，那么我们获得的是什么对象的锁呢？我们获得是该类的class对象锁，比如
Class Demo {
public static synchronized void test(){};
}
我们获得的就是Demo.class的对象锁。

2. sleep和wait的区别
a) sleep方法是静态方法，你无法sleep别的线程，只能让当前线程sleep。
b) sleep之前不需要获得任何对象的锁，直接sleep不会抛出异常。
c) sleep方法不会释放锁，比如
synchronized (Demo.lock) {
try {
Thread.sleep(200000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo对象上的锁在sleep期间不会被释放。

3. 线程继承问题

a) 如果未指明优先级，则被创建的线程和创建它的线程具有相同优先级。
b) 如果未指明ThreadGroup，则被创建的线程和创建它的线程使用相同的ThreadGroup。如果指定ThreadGroup为null,则系统会自动将本线程加入系统级的ThreadGroup。所以说不存在没有ThreadGroup的线程。
c) 如果未指明是否守护线程，则被创建的线程和创建它的线程具有相同的daemon属性。也就是说守护线程创建的线程如果未特别指定，则是守护线程，用户线程创建的线程如果未特别指定，则是用户线程。main线程是用户线程，除非被Thread.currentThread().setDaemon(true)方式改变。

4. 关于守护线程
a) 守护线程就是通过setDaemon(true)指定的线程，当没有其他非守护线程运行的时候，守护线程也会被自动终止，然后虚拟机退出。即使守护线程是个死循环。

5. 关于JVM终止，JVM在下列情况下会终止运行：
a) 所有非守护线程（即用户线程，非daemon线程）终止。假如有main线程和另外一个用户线程在运行，即使main线程终止了，还必须等待另外一个线程终止JVM才会终止。
b) 调用了Runtime类的exit方法（启动虚拟机的关闭序列）。
c) 外部程序强行终止虚拟机执行（非正常退出）。

6. 其他
所有的Java代码都是在某个线程中执行的，所以在任一行Java代码中使用Thread.currentThread()都可以得到当前运行线程。

分享到：

设计模式总结性试题 | Oracle 数据类型及存储方式(2)

2010-11-08 22:27
浏览 1019
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论