线程的一些控制方法

1.线程的启动，需要Thread类的start方法

/**
 * 线程控制 创建的线程要能够运行，需要通过Thread类的start方法启动 获取线程名称，默认为：Thread-数字
 * 
 * @author wxb
 *
 */
public class Demo1 {

	public static void main(String[] args) {
		ThreadA ta = new ThreadA();
		Thread t = new Thread(ta);
		t.start();

	}

}

class ThreadA implements Runnable {
	@Override
	public void run() {
		System.out.println("线程名字：" + Thread.currentThread().getName());

	}
}
class ThreadA1 implements Runnable {

    @Override
    public void run() {
        Thread.currentThread().setName("ThreadA1");// 设置线程名字
        System.out.println("线程名字：" + Thread.currentThread().getName());

    }

}

线程名字：Thread-0
线程名字：ThreadA1

2.判定线程是否处于活动状态

/**
 * 判定线程是否处于活动状态 : --就绪状态 --运行状态 --阻塞状态
 * 
 * @author wxb
 *
 */
public class Demo2 {

	public static void main(String[] args) {
		new ThreadB().start();
	}

}

class ThreadB extends Thread {
	@Override
	public void run() {
		System.out.println("检测线程是否是活动状态");
		System.out.println(Thread.currentThread().isAlive());
	}
}

检测线程是否是活动状态
true

3.设置线程的优先级

/**
 * 设置线程优先级 MAX_PRIORITY:最大为10 MIN_PRIORITY:最小为1 DEFAULT_PRIORITY:默认为5
 * 
 * @author wxb
 *
 */
public class Demo4 {
	public static void main(String[] args) {
		ThreadD td = new ThreadD();
		ThreadE te = new ThreadE();
		td.start();// 谁先启动，谁抢占资源的概率越大
		te.start();
		td.setPriority(Thread.MAX_PRIORITY);// 设置优先级为最大，10
		te.setPriority(Thread.MIN_PRIORITY);// 设置优先级为最小，1
	}
}

class ThreadD extends Thread {
	@Override
	public void run() {
		// 默认优先级为5
		// System.out.println(Thread.currentThread().getPriority());
		for (int i = 0; i < 10; i++) {
			System.out.println("ThreadD j---" + i);
		}
	}
}

class ThreadE extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("ThreadE i---" + i);
		}
	}
}

ThreadD j---0
ThreadE i---0
ThreadE i---1
ThreadE i---2
ThreadE i---3
ThreadE i---4
ThreadE i---5
ThreadE i---6
ThreadE i---7
ThreadE i---8
ThreadE i---9
ThreadD j---1
ThreadD j---2
ThreadD j---3
ThreadD j---4
ThreadD j---5
ThreadD j---6
ThreadD j---7
ThreadD j---8
ThreadD j---9

以上的代码每次运行的结果都不一样，线程抢占资源

4.线程休眠以及线程中断

/**
 * sleep:线程进入阻塞状态，是一个静态方法，在指定时间（毫秒）到达后进入就绪状态
 * 
 * @author wxb
 *
 */
public class Demo3 {

	public static void main(String[] args) {
		ThreadC tc = new ThreadC();
		tc.start();

	}

}

class ThreadC extends Thread {
	@Override
	public void run() {
		try {
			for (int i = 0; i < 10; i++) {
				sleep(1000);// 时间为1秒
				System.out.println("i---" + i);
				if (i == 5) {// 取消当前线程的阻塞状态
					interrupt();

				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
                        System.out.println("休眠中断.....");
                 }

	}
}

5.join和yield

/**
 * join:实现线程等待 
 * yield:让出线程又立即抢占
 * 
 * @author wxb
 *
 */
public class Demo5 {
	public static void main(String[] args) throws Exception {
		ThreadF tf = new ThreadF();
		tf.start();
		for (int i = 0; i < 10; i++) {
			// Thread.currentThread().sleep(10);// 休眠10毫秒，让ThreadF先执行完
			// Thread.currentThread().yield();//当前线程放弃占有CPU资源，让其他优先级不低于此线程的线程有机会执行
			if (i == 5) {
				tf.join();// 主线程必须等加入进来的线程执行完，再执行

			}
			System.out.println("主线程 i---" + i);
			// Thread.currentThread().join();
		}
	}
}

class ThreadF extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("ThreadF线程  i---" + i);
		}
	}
}

6.守护线程，必须在它的start方法之前进行设置，通过setDaemon方法传入true的参数，当程序只有守护线程时，该程序就可以结束运行了

/**
 * 守护线程 在线程启动前设置setDaemon(true)
 * 
 * @author wxb
 *
 */
public class Demo6 {

	public static void main(String[] args) throws Exception {
		ThreadH th = new ThreadH();
		th.setDaemon(true);// 让当前线程设置为守护线程
		th.start();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("主线程。。。" + i);
		}

	}

}

class ThreadH extends Thread {
	int i;

	@Override
	public void run() {
		while (true) {
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Hello,---" + ++i);
		}
	}
}