java线程常用的几个方法如getName()、setName()、sleep()、yield()、join()、setPriority()、setDaemon(true)

java线程常用的几个方法

/*
 * 线程常见的一些方法
 * 获取线程的名字
 * 设置线程的名字
 * sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，
 * yield()是让出当前的cpu,让其他线程执行，但是还有可能获取cpu，在执行当前的线程
 * 在t2对象中添加t.join(),当前线程暂停，等待制定的线程执行结束后，当前线程再继续
 * setPriority()   设置线程的优先级 	最高10级		默认5级		最低1级  在线程启动之前设置优先级
 * setDaemon(true) 守护线程不会单独执行，当其他非守护线程结束后，守护线程未执行完也会自动退出
 */
public class Threads2 {
	public static void main(String[] args) {
//		demo1();
//		demo2();
//		demo3();
//		demo4();
//		demo5();
//		demo6();
//		demo7();
	}

	private static void demo7() {
		/*
		 * java提供了俩类的线程：用户线程和守护线程(user thread and Daemon thread)
		 * 。用户线程是高优先级的线程
		 * 守护线程是低优先级的线程，它的作用仅仅是为用户线程提供服务。
		 * 正是由于守护线程是为用户线程提供服务的，仅仅在用户线程处于运行状态时才需要守护线程。
		 * 另外，一旦所有的用户线程都运行完毕，那么守护线程是无法阻止JVM退出的
		 * 守护线程不会单独执行，当其他非守护线程结束后，守护线程未执行完也会自动退出,
		 */
		for (int i = 0; i < 10; i++) {
			System.out.println("11111111111111");
		}
		Thread tm = new Thread() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 10; i++) {
					System.out.println("2222222222222222");
				}
			}
		};
		//守护线程必须设置在start()方法的前面,否则会出现异常
		tm.setDaemon(true);
		tm.start();
	}

	private static void demo6() {
		/*
		 * setPriority()	设置优先级
		 */
		Thread t1 = new Thread("klz"){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 10; i++) {
					System.out.println("22222222222222");
				}
			}
		};
		
		Thread t2 = new Thread("t") {
			public void run() {
				for(int i = 0; i < 10; i++) {
					System.out.println("5555555555555555555555555");
				}
			};
		};
		t2.setPriority(10);
		t1.start();
		t2.start();
	}

	private static void demo5() {
		/*
		 * 在t2对象中添加t.join(),当前线程暂停，等待制定的线程执行结束后，当前线程再继续
		 * join()执行与线程是否开启有很大关系
		 */
		
		Thread t = new Thread() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 100; i++) {
					
					System.out.println(this.getName() + "aaa" + i);
				}
			}
		};
		
		
		
		Thread t2 = new Thread(){
			public void run() {
				for(int i = 0; i < 100; i++) {
					if(i > 2) {
						try {
							t.join();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println("cccccccccc" + i);
				}
			};
		};
		

		
		t.start();
		t2.start();
		for(int i = 0; i < 100; i++) {
			 System.out.println("主线程第" + i +"次执行！");
			if(i > 5) {
				try {
					t.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	private static void demo4() {
		/*
		 * yield()是让出当前的cpu,让其他线程执行，但是还有可能获取cpu，在执行当前的线程
		 * yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，
		 * 它没有参数，即yield()方法只是使当前线程重新回到可执行状态，
		 * 所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，
		 * 另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，
		 * 这也和sleep()方法不同。
		 */
		new Thread() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 10; i++) {
					if(i == 2) {
						Thread.currentThread().yield();
					}
					System.out.println(this.getName() + "aaaa");
				}
			}
		}.start();
		
		for(int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "bbbbb");
		}
	}

	private static void demo3() {
		/*
		 * sleep()方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，
		 * 进入阻塞状态，该方法既可以让其他同优先级或者高优先级的线程得到执行的机会，
		 * 也可以让低优先级的线程得到执行机会。但是sleep()方法不会释放“锁标志”，
		 * 也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据。
		 */
		   new Thread() {
			   @Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 10; i++) {
					if(i == 3) {
						try {
							Thread.currentThread().sleep(5000);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println(this.getName() + "aaaa");
				}
			}
		   }.start();
		   
		   for(int i = 0; i < 100; i++) {
			   System.out.println(Thread.currentThread().getName() + "bbbbbb");
		   }
	}

	private static void demo2() {
		/*
		 * 设置线程名字的方法
		 * 在new Thread(){} 里面可以在Thred的构造方法里面直接设置名字
		 * Thread t = new Thread(new Runnable(){})  需要使用t.setName();设置线程的名字
		 */
		new Thread("klz") {								//设置线程的名字
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "aaa");
				}
			}
		}.start();
		
		Thread t = new Thread(){
			public void run() {
				for(int i = 0; i < 100; i++) {
					System.out.println("cccccc"+this.getName());
				}
			};
		};
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 100; i++) {
					System.out.println("ddd"+Thread.currentThread().getName());
				}
			}
		});
		
		t.setName("kz");
		t2.setName("hello");
		t.start();
		t2.start();
		
		for(int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() +"bbbbbbbbbbbbbbb");
		}
	}

	private static void demo1() {
		/*
		 * 获取线程的名字
		 * 在new Thread(){} 里面可以使用this.getName()和Thread.currentThread.getName()获取线程的名字
		 * 在主线程和实现Runnable的线程里面只能用Thread.currentThread.getName()获取线程的名字
		 */
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + "aaaa" + this.getName());
				}
			}
		}.start();
		
		for(int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() +"bbbbbbbbbbbbbbb");
		}
	}
}