java 线程让步 java线程操作

在线程中所有的方法都是在Thread类中。

线程操作的主要方法如下：

public Thread（Runnable   target ） Thread对象接受一个实现了Runnable接口的对象，并实例化这个Thread线程！
public Thread（Runnable   target ，String name ）  Thread对象接受一个实现了Runnable接口的对象，并实例化这个Thread线程，并且为这个线程命名！
public  Thread（String name ） 实例化这个线程，并为这个线程对象命名！
public static   Thread  currentThread()  返回正在执行的线程!
public  final  String getName() 得到线程的名字！
public  final int getPriority()得到线程的优先级！
public  boolean  isInterrupted()判断线程是否中断！ 
public final boolean  isAlive（） 判断线程是否在活动！
public final  void join（） throws  InterruptedException等待线程死亡！
public final void join（long  millis） throws  InterruptedException  
public void run（） 执行线程
public final  void setName（String name）  
public  final  void setPriority(int  priority)设定线程的优先级！
public final void sleep（long  millis）throws  InterruptedException  使当前正在执行的线程休眠多少毫秒！
public static void yeild（） 暂停当前对象并使其他线程执行！
public final void  setDaemon(boolean  on) 

下面通过例子程序来对上边一些方法加以说明：

1 设定线程的名字！

首先我们可以通过Thread类中的setName和getName 这两个方法来设定线程的名字和得到线程的名字！当然我们还可以为两个不同的线程设定相同的名字，但是为了能够清晰的区分，强烈建议不要这样做！如果线程没有设定名字的话，系统会自动的为线程分配一个名称！一般为了方便起见，我们在线程启动之前就把给线程取好名字，因为在中途取名的话一定会很麻烦的！

代码如下：

package com.pzhu.www.thread;

public class ThreadTest01 {

	public static void main(String[] args) {

		Thread01 a = new Thread01();
		a.setName("gongyansong");
		String name = a.getName();
		Thread01 b = new Thread01();
		b.setName("gongyansong");
		String name1 = b.getName();
		System.out.println("a线程的名字为：  "+name);
		System.out.println("b线程的名字为：  "+name1);
		a.start();

	}
}

下面讲一下这个怎样取得当前线程！

下面这个得到当前线程名的代码：

这里要注意的是得到线程的方法时currentThread（） ，这个方法是个静态方法直接通过类名调用即可！

package com.pzhu.www.thread;

public class CurrentThread extends Thread {

	public void run(){
		
		for(int i=0;i<5;i++){
			System.out.println("当前线程名为："+Thread.currentThread().getName());
		}
	}
}


测试代码如下：

package com.pzhu.www.thread;

public class ThreadTest02 {

	public static void main(String[] args){
		
		CurrentThread ct = new CurrentThread();
		ct.setName("gongyuansong");
		ct.start();
		ct.run();
	}
}

结果如图所示：

结果我们会发现这其中会出现名字叫main 这个线程！这到底是为什呢？

首先在执行start方法时执行的是gongyuansong这个线程，而在执行ct.run这个方法时我们是通过main方法调用的，所以会得到这样的结果！这里就可以看出java中的main方法其实也是一个线程。同样在启动JVM的时候操作系统为程序启动了一个JVM的进程！同时JVM具备gc机制，其实gc机制也是一个线程，所以我们运行一个java程序的时候至少启动了两个线程，主线程，和gc线程！

2 判断线程是否启动!

package com.pzhu.www.thread;

public class ThreadTest02 {

	public static void main(String[] args){
		
		CurrentThread ct = new CurrentThread();
	
		System.out.println("start前，线程是否启动:"+ct.isAlive());
		ct.start();
		System.out.println("start后，线程是否启动:"+ct.isAlive());
		
		for(int i=0;i<5;i++){
			System.out.println("当前正在执行的线程：   "+Thread.currentThread().getName());
		}
		
		System.out.println("start后，线程是否启动:"+ct.isAlive());
		//上面这行代码的值是不确定的，因为不知道是主线程先执行完还是ct这个线程先执行完！
		
	}
}

结果如下：

3 线程的强制运行！

线程强制运行使用的方法是join（）这个方法！

在线程强制运行期间，其他的线程不能运行，只有等到这个强制运行的线程运行完了其他的线程才能使用！

package com.pzhu.www.thread;

public class JoinThreadTest {

	public static void main(String[] args) {

		JoinThread  jt01 = new JoinThread();
		jt01.setName("jt01");
	
		for(int i=0;i<10;i++) {
			
			System.out.println("main线程执行中....");
			if(i==5){
//				判断如果i的值为5的话我们就启动jt01这个线程，并且打断当前线程强制执行！
//				这个的join是要抛出异常的所以必须try起来
				try {
					jt01.start();
					jt01.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

		
	}

}

4 线程的休眠

线程的休眠是通过sleep这个方法实现的，这个方法是一个static方法，所以我们可以直接使用Thread.sleep()来调用，同样也可以使用线程类的对象来调用，但是不建议这样使用！这个方法很简单，所以不再贴代码！

5 后台线程就是在后台执行的现场，java中通过setDaemon()方法来将一个线程设定为后台线程！如果写了一个死循环的线程的话，前台线程是一直会执行的，而后台线程不会一直执行，后台线程会在前台所有的线程结束之后也随之结束的！所以后台线程不会一直执行的！

下面通过代码来说明：

线程代码：

package com.pzhu.www.backgroundthread;

public class BackGroundThread01 extends Thread {

	public void run() {
		int i = 0;
		while (true) {
			System.out.println("线程" + Thread.currentThread().getName()
					+ "运行中......." + i++);
		}
	}

}

测试代码：

package com.pzhu.www.backgroundthread;

public class BackGroundThreadTest01 {

	public static void main(String[] args) {

		BackGroundThread01 bg = new BackGroundThread01();
		bg.setName("BGThread");
		bg.setDaemon(true);
		bg.start();
		
		
	}

}

而出现的结果每次都不会一样，这里不多说！

6线程的优先级

在java的线程执行过程当中，线程在执行之前线程都会保持就绪状态，但是优先级高的线程就有可能被先执行！

设置线程的优先级是通过setPriority这个方法的，同时还可以通过Thread.currentThread().getPriority（）这个方法得到当前线程的优先级！

下面通过代码说明：

线程类如下：

package com.pzhu.www.priority;

public class Thread01 extends Thread {

	public void run(){
		
		for(int i=0;i<5;i++){
			
			System.out.println("当前线程名："+Thread.currentThread().getName()+" 当前线程的优先级:"+Thread.currentThread().getPriority()+"     "+i);
		
		}
	}
	
}

测试类：

package com.pzhu.www.priority;

public class ThreadTest01 {


	public static void main(String[] args) {

		Thread01 t1 = new Thread01();
		Thread01 t2 = new Thread01();
		Thread01 t3 = new Thread01();
		t1.setName("t1");
		t2.setName("t2");
		t3.setName("t3");
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();
		t2.start();
		t3.start();
		
		
	}

}

最后我们会发现结果是不确定的，好像并没有实现优先级。但是实际上优先级只是会增加优先执行的几率，并不能完全实现优先级的控制，还有就是这几个线程本来就是并发执行的，所以这里面还有并发的因数在里面！线程里面优先级是通过1到10的int型的数表示的，数字越大优先级越高，同时java提供三个常量来表示三个优先级别，常量分别是：

MIN_PRIORITY   最低优先级

NORM_PRIORITY 中等优先级

MAX_PRIORITY 最高优先级

7 线程的礼让

java中可以通过yield（）方法来实现线程的礼让，即将现在正在执行的线程暂定，让其他的线程执行。下面通过代码说明：

线程类

package com.pzhu.www.yield;

public class Thread01 implements Runnable {

	@SuppressWarnings("static-access")
	public void run() {

		for(int i=0;i<10;i++){
			if(i>=3) {
				Thread.currentThread().yield();
				
			}
			System.out.println(Thread.currentThread().getName()+"线程执行中.....");
		}
	}

}

测试代码如下：

package com.pzhu.www.yield;

public class ThreadTest01 {

	public static void main(String[] args) {

		Thread01 t = new Thread01();
		Thread thread01 = new Thread(t);
		Thread thread02 = new Thread(t);
		Thread thread03 = new Thread(t);
		thread01.start();
		thread02.start();
		thread03.start();
		
		
	}

}

总结：
以上的方法都是Thread类中的方法，这里只简单的介绍，有不懂的自己去查看文档！