- <span style="font-size:16px;"><strong>package com.thread;
- public class TestThreadShutDown {
- /**
- *
- * 友情 关闭,而不可以用 stop()这样粗暴的方法。
- *
- * @param args
- */
- public static void main(String[] args) {
- Runner4 r = new Runner4();
- Thread t = new Thread(r);
- t.start();
- for(int i=0;i<100000;i++) {
- if(i%10000 == 0 & i>0){
- System.out.println("in thread main i=" + i);
- }
- }
- System.out.println("Thread main is over");
- r.shutDown();
- }
- }
- class Runner4 implements Runnable{
- private boolean flag = true;
- @Override
- public void run() {
- int i = 0;
- while(flag == true){
- System.out.println(" " + i);
- }
- }
- public void shutDown(){
- flag = false;
- }
- }</strong></span>
- <span style="font-size:16px;"><strong>package com.thread;
- /************************
- *
- join()方法使当前线程停下来等待,直至另一个调用join方法的线程终止。
- 值得注意的是,线程的在被激活后不一定马上就运行.
- 而是进入到可运行线程的队列中。
- 但是join()可以通过interrupt()方法打断线程的暂停状态,
- 从而使线程立刻抛出InterruptedException。
- *
- * @author wang.dm
- *
- */
- public class Test_Join_1 {
- /**
- * @param args
- */
- public static void main(String[] args) {
- Thread t = new Thread(new RunnableIm());
- t.start();
- try {
- // 当main 线程调用t.join 时,main 线程等待t 线程 ,等待时间是1000
- t.join(1000); // 主线程 只等1 秒,就等待一秒钟,不管子线程什么时候结束。
- System.out.println("JOIN 结束");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- class RunnableIm implements Runnable{
- @Override
- public void run() {
- try {
- System.out.println("开始睡觉……");
- Thread.sleep(9000); // T 线程睡 10秒钟。而 main 线程 只等待一秒钟。
- System.out.println("停止睡觉……");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }</strong></span>
- <span style="font-size:16px;"><strong>package com.thread;
- /*
- *
- 在main方法中 通过new ThreadTest(t).start();实例化ThreadTest 线程对象,
- 它在holdThreadLock()方法中,通过 synchronized (thread),获取线程对象t的锁,并Sleep(9000)后释放,
- 这就意味着,即使
- main方法t.join(1000),等待一秒钟,
- 它必须等待ThreadTest 线程释放t锁后才能进入wait方法中,
- 它实际等待时间是9000+1000 MS
- 运行结果是:
- getObjectLock
- Begin sleep
- End sleep
- ReleaseObjectLock
- joinFinish
- */
- public class JoinTest {
- public static void main(String[] args) {
- Thread t = new Thread(new RunnableImpl());
- new ThreadTest(t).start();
- t.start();
- try {
- t.join(1000);
- System.out.println("joinFinish");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- class ThreadTest extends Thread {
- Thread thread;
- public ThreadTest(Thread thread) {
- this.thread = thread;
- }
- @Override
- public void run() {
- holdThreadLock();
- }
- public void holdThreadLock() {
- synchronized (thread) { // 获取 线程 t 的锁。
- System.out.println("getObjectLock");
- try {
- Thread.sleep(9000);
- } catch (InterruptedException ex) {
- ex.printStackTrace();
- }
- System.out.println("ReleaseObjectLock");
- }
- }
- }
- class RunnableImpl implements Runnable {
- @Override
- public void run() {
- try {
- System.out.println("Begin sleep");
- Thread.sleep(2000);
- System.out.println("End sleep");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- </strong></span>
- <span style="font-size:16px;"><strong>package com.thread;
- import java.util.Date;
- public class TestInterrupt {
- /**
- interrupt()
- interrupt()中断线程。需要注意的是,InterruptedException是线程自己从内部抛出的,
- 并不是interrupt()方法抛出的。
- 对某一线程调用interrupt()时,如果该线程正在执行普通的代码.
- 那么该线程根本就不会抛出InterruptedException。
- 但是,一旦该线程进入到wait()/sleep()/join()后,就会立刻抛出InterruptedException。
- * @param args
- */
- public static void main(String[] args) {
- MyThread thread = new MyThread();
- thread.start();
- try {
- /**************************
- *
- sleep()
- 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),
- 此操作受到系统计时器和调度程序精度和准确性的影响。
- 由于sleep()方法是Thread类的方法,因此它不能改变对象的机锁。
- 所以当在一个Synchronized方法中调用sleep()时,线程虽然休眠了.
- 但是对象的机锁没有被释放,其他线程仍然无法访问这个对象。
- sleep()方法不需要在同步的代码块中执行。
- 但是sleep()可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException。
- */
- Thread.sleep(10000); //在哪个线程里调用 sleep方法 就让那个线程睡眠。主线程睡眠了。
- } catch (InterruptedException e) {
- thread.interrupt();
- }
- }
- }
- class MyThread extends Thread {
- boolean flag = true;
- public void run() {
- while(flag){
- System.out.println("====" + new Date() + "=====");
- try {
- sleep(1000);
- } catch (InterruptedException e) {
- return;
- }
- }
- }
- }</strong></span>
- <span style="font-size:16px;"><strong>package com.thread;
- public class TestYield {
- /**
- * @param args
- */
- public static void main(String[] args) {
- MyThread3 t1 = new MyThread3("t1");
- MyThread3 t2 = new MyThread3("t2");
- t1.start();
- t2.start();
- }
- }
- class MyThread3 extends Thread {
- MyThread3(String s){
- super();
- }
- public void run(){
- for(int i=0;i<=100;i++) {
- System.out.println(getName() + " : " + i);
- if(i%10 == 0){
- //Yield()方法是停止当前线程,让同等优先权的线程运行。
- //如果没有同等优先权的线程,那么Yield()方法将不会起作用。
- yield();
- }
- }
- }
- }</strong></span>