【java学习笔记s】线程2

3，线程的状态

1）新生状态：

  用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态，处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态。

2）就绪状态：

处于就绪状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列，等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，他就会从等待执行状态进入执行状态，系统挑选的动作称之为“CPU调度”，一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。

3）运行状态：

在运行状态的线程执行自己的run方法中代码，直到调用其他方法而终止、或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

4）阻塞状态：

处于运行状态的线程在某些情况下，如执行了sleep方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。

5）死亡状态：

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个，一个是正常运行的线程完成了它的全部工作，另一个是线程被强制性地终止，如通过执行stop或destory方法来终止一个线程（不推荐使用这两个方法，前者会产生异常，后者是强制终止，不会释放锁）

停止线程：

1）自然终止：线程体正常执行完毕
2）外部干涉：
线程类中定义线程体使用的标志
线程体使用该标志
提供对外的方法改变该标志
外部根据条件调用该方法即可

4，阻塞

4.1 join：合并线程

public class JoinDemo extends Thread {
public static void main(String[] args) throws InterruptedException {
JoinDemo demo = new JoinDemo();
Thread t = new Thread(demo);//新生
t.start();//就绪

for(int i=0;i<1000;i++){
if(50==i){
t.join();  //main阻塞
}
System.out.println("main..."+i);
}

}
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("join..."+i);
}
}
}

4.2 yield：暂停当前正在执行的线程对象，并执行其他线程

public class YieldDemo extends Thread{

public static void main(String[] args) {
YieldDemo demo = new YieldDemo();
Thread t = new Thread(demo);//新生
t.start();//就绪

for(int i=0;i<1000;i++){
if(i%20==0){
//暂停本线程
Thread.yield();//写在哪个线程里，暂停哪个线程
}
System.out.println("main..."+i);
}
}

@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("yield..."+i);
}
}
}

4.3 sleep：休眠，暂停当前线程，不释放锁

1）与时间相关：倒计时

2）模拟网络延时

/**
* 倒计时
* 1，倒数10个数，1秒内打印一个
* @author zhaixiangbo
*
4000

*/
public class SleepDemo {

public static void main(String[] args) throws InterruptedException {
int num = 10;
while(true){
System.out.println(num--);
Thread.sleep(1000); //暂停
if(num<=0){
break;
}
}
}
}

5，线程基本信息

currentThread（）是static方法，写在哪个线程里就代表哪个线程

package cn.zxb.test.info;

/**
* Thread.currentThread()  //当前线程
* setName()  设置名称
* getName()  获取名称
* isAlive()  判断状态
*
*/
public class InfoDemo {

public static void main(String[] args) throws InterruptedException {
MyThread it = new MyThread();
Thread p1 = new Thread(it,"挨踢1");
MyThread it2 = new MyThread();
Thread p2 = new Thread(it2,"挨踢2");
p1.setPriority(Thread.MIN_PRIORITY);
p1.setPriority(Thread.MAX_PRIORITY);//设置优先级
p1.start();
p2.start();

Thread.sleep(100);
it.stop();
it2.stop();

/*
MyThread it = new MyThread();
Thread proxy = new Thread(it,"挨踢");
proxy.setName("test");
System.out.println(proxy.getName());
System.out.println(Thread.currentThread().getName());
proxy.start();
System.out.println("启动后的状态："+proxy.isAlive());
Thread.sleep(200);
it.stop();
Thread.sleep(100);
System.out.println("停止后的状态："+proxy.isAlive());*/  //currentThread()

}
}

class MyThread implements Runnable{

private boolean flag = true;
private int num = 0;

@Override
public void run() {
while(flag){
System.out.println(Thread.currentThread().getName()+"-->"+num++);
}
}

public void stop(){
this.flag = !this.flag;
}
}

设置优先级，优先级小不代表不会执行，只是执行的概率小

优先级代表的是概率，不是绝对的优先级，没有先后顺序

6，线程同步

        由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：sychronized方法和synchronized块。

7，死锁

过多的同步容易造成死锁

8，任务调度

Timer定时器类
TimerTask任务类
Timer类实现的是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其他线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以该类具备多线程的能力。在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码写在run方法内部，然后通过Timer类启动线程的执行。

package cn.zxb.test.info;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo {

public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {

@Override
public void run() {
System.out.println("so easy...");
}
},new Date(System.currentTimeMillis()+1000),200);
}
}