Thread详解

1.继承THread类创建线程类

<span style="font-family:Times New Roman;font-size:18px;">package com.simplethread.test;
public class FirstThread extends Thread{
	private int i;
	//重写run()方法,run()方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//当线程继承Thread类时,直接使用this即可获取当前线程
			//Thread对象的getName()返回当前线程的名字
			//因此可以直接调用getName()方法返回当前线程的名字
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<5;i++)
		{
			//调用Thread的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==2)
			{
				//创建并启动第一个线程
				new FirstThread().start();
				//创建并启动第二个线程
				new FirstThread().start();
			}			
		}
	}
}
</span>
2.实现Ruunable接口创建线程类

package com.simplethread.test;
public class SecondThread implements Runnable{
	private int i;
	//run()方法同样是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//当线程类实现Runnable接口时
			//如果想获取当前线程,只能用Thread.currentThread()方法
			System.out.println(Thread.currentThread().getName()					+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<5;i++)
		{
			System.out.println(Thread.currentThread().getName()
					+" "+i);
			if(i==2)
			{
				SecondThread st=new SecondThread();
				//通过new Thread(target,name)方法创建新线程
				new Thread(st,"新线程1").start();
				new Thread(st,"新线程2").start();
			}
		}
	}
}

3.使用Callable和Future创建线程

package com.simplethread.test;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThirdThread {
	public static void main(String[] args) {		
		//先创建Callable对象
		ThirdThread rt=new ThirdThread();
		FutureTask<Integer> task=new FutureTask<Integer>( 
				new Callable<Integer>() {  
            public Integer call() { 
            	int i=0;
            	for(;i<10;i++)
            	{
            		System.out.println(Thread.currentThread().getName()
            				+"的循环变量i的值:"+i);
            	}
                return i;  
            }  
        });
		for(int i=0;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()
					+"的循环变量i的值:"+i);
			if(i==3)
			{
				//实质还是以Callable对象来创建并启动线程
				new Thread(task,"有返回值的线程").start();
			}
		}
		try
		{
			//获取线程返回值
			System.out.println("子线程返回值:"+task.get());
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}
4.线程的生命周期

package com.simplethread.test;
public class InvokeRun extends Thread{
	private int i;
	//重写run()方法,run()方法的方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			//直接调用run()方法时,Tread的this.getName()返回的是该对象的名字
			//而不是当前线程的名字
			//使用Thread.currentThread().getName()总是获取当前线程的名字
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++)
		{
			//调用Thread的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==5)
			{
				//直接调用线程的run()方法
				//系统会把线程对象当成普通对象,把run()方法当成普通方法
				//所以下面两行代码并不会启动两个线程,而是依次执行两个run()方法
				new InvokeRun().run();
				new InvokeRun().run();
			}
		}
	}
}
5.线程死亡

package com.simplethread.test;
public class StartedDeadThread extends Thread{
	private int i;
	//重写run()方法,run()方法的方法体就是线程执行体
	public void run()
	{
		for(;i<10;i++)
		{
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		//创建线程对象
		StartedDeadThread sd=new StartedDeadThread();
		for(int i=0;i<10;i++)
		{
			//调用Threade的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName()
					+" "+i);
			if(i==5)
			{
				//启动线程
				sd.start();
				//判断启动后台线程的isAlive()值,输出true
				System.out.println(sd.isAlive());
			}
			//当线程处于新建、死亡两种状态时,isAlive()方法返回false
			//当i>5时,该线程肯定已经启动过了,如果sd.isAlive()为假时
			//那就是死亡状态了
			if(i>5&&(sd.isAlive()))
			{
				//试图再次启动线程
				sd.start();
			}
		}
	}
}

6.控制线程

Join线程:

package com.simplethread.test;
public class JoinThread extends Thread{
	//提供一个有参数的构造器,用于设置该线程的名字
	public JoinThread(String name)
	{
		super(name);
	}
	//重写run()方法,定义线程执行体
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+" "+i);			
		}
	}
	public static void main(String[] args) throws InterruptedException {
			//启动子线程
		new JoinThread("新线程").start();
		for(int i=0;i<10;i++)
		{
			if(i==2)
			{
				JoinThread jt=new JoinThread("被Join的线程:");
				jt.start();
				//main线程调用了jt线程的join()方法,main线程
				//必须等jt执行结束后向下执行
				jt.join();
			}
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}
7.后台线程

package com.simplethread.test;
public class DaemonThread extends Thread{
	//定义后台线程的线程执行体与普通线程没有任何区别
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		DaemonThread t=new DaemonThread();
		//将此线程设置成后台线程
		t.setDaemon(true);
		t.start();
		//启动后台线程
		for(int i=0;i<5;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		//------程序执行到此处,前台线程(main线程)结束-------
		//后台线程也应该随之结束
	}
}

8.线程睡眠:sleep

package com.simplethread.test;
import java.util.Date;
public class SleepTest {
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++)
		{
			System.out.println("当前时间:"+new Date());
			//调用Sleep()方法让当前线程暂停1s
			Thread.sleep(2000);
		}

	}

}

9.线程让步:yield

package com.simplethread.test;
public class YieldTest extends Thread{
		public YieldTest(String name)
		{
			super(name);
		}
		//定义run()方法作为线程执行体
		public void run()
		{
			for(int i=0;i<10;i++)
			{
				System.out.println(getName()+" "+i);
				//当i=5时,使用yield()方法让当前线程让步
				if(i==5)
				{
					Thread.yield();
				}
			}
		}
	public static void main(String[] args) {
		//启动两个并发线程
		YieldTest yt1=new YieldTest("高级");
		//将yt1设置成最高优先级
		yt1.setPriority(Thread.MAX_PRIORITY);
		yt1.start();
		YieldTest yt2=new YieldTest("低级");
		//将yt2设置成最高优先级
		yt2.setPriority(Thread.MIN_PRIORITY);
		yt2.start();
	}
}

10.改变线程优先级

package com.simplethread.test;
public class PriorityTest extends Thread{
	//定义一个有参数的构造器,用于创建线程指定时指定name
	public PriorityTest(String name)
	{
		super(name);
	}
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println(getName()+",其优先级是: "
		+getPriority()+",循环变量的值为:"+i);
		}
	}
	public static void main(String[] args) {
		//改变线程的优先级
		Thread.currentThread().setPriority(6);
		for(int i=0;i<20;i++)
		{
			if(i==10)
			{
				PriorityTest low=new PriorityTest("低级");
				low.start();
				System.out.println("创建之初的优先级:"+
				low.getPriority());
				//设置改线程为最低优先级
				low.setPriority(Thread.MIN_PRIORITY);
			}
			if(i==15)
			{
				PriorityTest high=new PriorityTest("高级");
				high.start();
				System.out.println("创建之初的优先级:"+
				high.getPriority());
				//设置该线程为最高优先级
				high.setPriority(Thread.MAX_PRIORITY);
			}
		}
	}
}










































©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页