Java基础————线程知识

提示：
线程创建：点我带你去看看线程创建！

线程优先级及为线程设置名字

在线程开启之前我们可以为线程设置线程优先级，但是这个优先级并非绝对的优先，只是相应的增加线程调用的概率，线程优先级范围：1~10，未设置优先级时默认为5。我们可以直接使用1-10对线程进行设置优先级，也可以使用线程提供的优先级常量进行设置：MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY、这三个常量进行设置他们对应的优先级为10、5、1。

public class TreadNamePriorityTest {
	public static void main(String[] args) {
		 Thread t1 =new A("A");//这里是通过构造方法设置线程名
		 Thread t2 =new B();
		 Thread t3 =new Thread(new C());
		 t2.setName("B");//这里是通过调用方法设置线程名
		 t3.setName("C");
		 
		 t1.setPriority(Thread.MAX_PRIORITY);10
		 t2.setPriority(Thread.NORM_PRIORITY);5
		 t3.setPriority(Thread.MIN_PRIORITY);1
		 
		 t1.start();
		 t2.start();
		 t3.start();
	}

}

class A extends Thread{
	//带传递名字的构造方法
	public A(String name) {
		super(name);
	}

	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+":"+(i+1));
		}
	}
}
class B extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+":"+(i+1));
		}
	}
}
class C implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+":"+(i+1));
		}	
	}
}

运行结果：
A:1
C:1
C:2
C:3
B:1
B:2
B:3
B:4
B:5
C:4
A:2
A:3
A:4
A:5
C:5

线程的礼让

线程礼让就是暂时让出cpu的使用权，进入就绪状态，等待被调度，也就是说线程让出资源后，其他线程如果没有抢到资源又被礼让线程抢到资源后，礼让的线程还是会继续运行，所以线程礼让并不是终止线程运行，可以说就是休息一下而已。

public class ThreadYieldTest {
	public static void main(String[] args) throws InterruptedException {
		MyThread2 t2 = new MyThread2("我是礼让线程：");
		t2.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("我是主线程："+(i+1));
			Thread.currentThread().sleep(1000);
		}
	}
}

//用于礼让线程
class MyThread2 extends Thread{
	
	public MyThread2(String name) {
		super(name);
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+(i+1));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//礼让一下，只是让出cpu，让出后又继续抢资源，可能刚让出cpu又抢到CPU资源
			Thread.yield();
		}
	}
}

运行结果：
我是主线程：1
我是礼让线程：:1
我是主线程：2
我是礼让线程：:2
我是主线程：3
我是礼让线程：:3
我是主线程：4
我是礼让线程：:4
我是礼让线程：:5
我是主线程：5
我是礼让线程：:6
我是主线程：6
我是主线程：7
我是礼让线程：:7
我是主线程：8
我是礼让线程：:8
我是礼让线程：:9
我是主线程：9
我是主线程：10
我是礼让线程：:10

线程合并

所谓线程合并就是让调用的线程与所在线程合并在一起，比如说在主线程中线程1去调用线程合并的方法，这时主线程中和线程1就合并了，运行的时候就必须等到线程1运行完后主线程才开始运行。

public class ThreadJoinTest {
	public static void main(String[] args) throws InterruptedException {
		
		MyThread1 t1 = new MyThread1("我是合并线程：");
		t1.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("我是主线程："+(i+1));
			Thread.currentThread().sleep(1000);
			//t1调用join后,把t1线程合并到主线程中，等到t1运行完才再运行主线程的后续代码
			t1.join();
		}
	}
}
//合并线程
class MyThread1 extends Thread{
	
	public MyThread1(String name) {
		super(name);
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+(i+1));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

运行结果：
我是主线程：1
我是合并线程：:1
我是合并线程：:2
我是合并线程：:3
我是合并线程：:4
我是合并线程：:5
我是合并线程：:6
我是合并线程：:7
我是合并线程：:8
我是合并线程：:9
我是合并线程：:10
我是主线程：2
我是主线程：3
我是主线程：4
我是主线程：5
我是主线程：6
我是主线程：7
我是主线程：8
我是主线程：9
我是主线程：10

中断线程

中断线程，谁调用谁就中断运行。

public class ThreadInterruptTest {

	public static void main(String[] args) throws InterruptedException{
		
		MyThread3 t3 = new MyThread3("我是中断线程.........");
		t3.start();
		Thread.sleep(500);
		t3.interrupt();
	}
}

//中断线程
class MyThread3 extends Thread{
	
	public MyThread3(String name) {
		super(name);
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(!Thread.currentThread().isInterrupted()) {
			System.out.println(Thread.currentThread().getName());
		}
		if(!Thread.currentThread().isInterrupted()) {
			
		}
	}
}

运行结果：
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…
我是中断线程…

线程转后台线程

后台线程也叫守护线程，其含义是后台线程默默的守护着非后台线程，直到非后台线程停止运行消亡后，后台线程就跟着自动消亡。

public class GuardTreadTest {
	
	public static void main(String[] args) throws InterruptedException {
		GuardThread t0 = new GuardThread();//创建一个线程对象
		t0.setDaemon(true);//设置当前线程为后台线程
		t0.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("我是主线程："+(i+1));
			Thread.currentThread().sleep(1000);
		}
		
	}
	
}
//子线程,上面的主方法中我将会将它创建的线程对象转为后台线程
class GuardThread extends Thread{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			System.out.println("我是后台线程，运行中.......");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

运行结果：
我是主线程：1
我是后台线程，运行中…
我是后台线程，运行中…
我是主线程：2
我是后台线程，运行中…
我是主线程：3
我是后台线程，运行中…
我是主线程：4
我是主线程：5
我是后台线程，运行中…
我是后台线程，运行中…
我是主线程：6
我是主线程：7
我是后台线程，运行中…
我是后台线程，运行中…
我是主线程：8
我是主线程：9
我是后台线程，运行中…
我是后台线程，运行中…
我是主线程：10
我是后台线程，运行中…

分析：将子线程转成后台线程后，必须等待其他线程消亡后，该后台线程才会消亡，否者在其他线程运行时，它也会参与资源的争抢。

提示

以上只是我自己的看法，如有雷同纯属意外。如有错误，也请谅解，勿喷！如有收获或疑问，欢迎点赞评论！