线程是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。
线程的一些特性：
- 所有的Java代码都是在某个线程中执行的，所以在任一行Java代码中使用Thread.currentThread()都可以得到当前运行线程。
- JVM允许多个线程并发执行，虽然同一时刻只能有一个线程占用CPU，但每个线程占有的时间片非常短，所以人类的感官上多个线程是并发执行的。
- 当 JVM启动时，至少有一个用户线程运行，即执行某个类的main方法的线程。
线程在下列情况之一终止运行：
- Thread.run方法运行完毕(或者是Thread包含的Runnable对象的run方法执行完毕)
- run方法内的代码运行时发生异常。
创建线程：
- 继承Thread类，覆盖run方法
- 实现Runnable接口，通过Thread类的带Runnable参数的构造函数传入到Thread对象内,一种常用的方式：
Java代码
- Thread t=new Thread(new Runable(){
- public void run(){
- //do something
- }
- });
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实现）：
- n-1关系，所有JVM线程都在同一个OS线程中运行。
- n-m关系，一个JVM线程是可以在多个OS线程中运行，一个OS线程可运行多个JVM线程，不管硬件是多核还是单核。
- 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.
- 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()都可以得到当前运行线程。
4353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
