线程的使用

package cn.ekgc.javasenior.day20210630;

public class ThreadNote {
	public static void main(String[] args) {
		
	}
}

 Thread

package cn.ekgc.javasenior.day20210630.base;

public class ThreadDemo01 {
	public static void main(String[] args) {
		// 创建 MyThread 对象
		MyThread myThread = new MyThread();
		// 对于每个线程，都可以进行命名，则通过该线程的 setName() 进行命名
		myThread.setName("李静平");
		// 如果只是创建了一个线程对象，那么这个线程是不执行的，需要调用该线程对象的 start() 启动该线程
		// 即使启动了一个线程，那么这个线程也不一定就立刻被执行，只有当操作系统调度该线程为其分配 CPU 资源后，
		// 这个线程才能够执行。
		myThread.start();
		// 那么此时对于操作系统来说就存在两个线程，分别是 main 和 myThread，
		// 当 myThread 启动后，这个线程就脱离了 main 的管理，独立运行，
		// 也设定 main 线程运行的内容
		for (int i = 0; i < 100; i++) {
			System.out.println("这是 main 线程的第 " + (i + 1) + " 次输出！");
		}
	}
}

// 一个 .java 文件中，可以存在多个 class 类，但是只能够有一个 public class
// 虽然多个 class 可以写在一个 .java 文件中，但是编译之后获得的 .class 文件
// 确是一个 class 类一个独立的 .class 文件。
// 要想获得一个能够创建线程的类，只需要让该类继承 java.lang.Thread 类即可
class MyThread extends Thread {
	// 对于一个线程来说，只运行该线程的 run()，因此需要运行的代码必须写在 run()
	// 重写 run()
	@Override
	public void run() {
		// 如果需要得到到时候的线程名，则可以通过 Thread.currentThread().getName() 获得
		String threadName = Thread.currentThread().getName();
		// 当创建了一个 MyThread 线程执行，会执行的代码
		for (int i = 0; i < 100; i++) {
			System.out.println("这是 " + threadName + " 线程的第 " + (i + 1) + " 次输出！");
		}
	}
}

package cn.ekgc.javasenior.day20210630.base;

public class Threadtest {
public static void main(String[] args) {
	Mythread01 my = new Mythread01();
	my.setName("李静平");
	my.start();
	for(int i = 0;i<10;i++) {
		System.out.println("这是main第"+(i+1)+"次运行");
		
		}
	}
}
class Mythread01 extends Thread{
	
	@Override
	public void run() {
		String threadname = Thread.currentThread().getName();
		for(int i = 0;i<10;i++) {
			System.out.println("这是"+threadname+"第"+(i+1)+"次运行");
			
		}
	}
	
}

 Runnable

package cn.ekgc.javasenior.day20210630.base;

public class RunnableDemo01 {
	public static void main(String[] args) {
		// 创建 MyRunnable 类的对象
		MyRunnable myRunnable = new MyRunnable();
		// 创建 Thread 对象，并且将 MyRunnable 对象作为构造方法的参数传入
		Thread myThread = new Thread(myRunnable);
		// 启动 myThread 线程
		myThread.start();
		
		for (int i = 0; i < 100; i++) {
			System.out.println("这是 main 的第 " + (i + 1) + " 次运行！");
		}
	}
}

// 要想获得一个多线程类，除了继承 Thread 类，也可以实现 Runnable 接口
class MyRunnable implements Runnable {
	// 对于实现了 Runnable 接口的类对象，只是线程在启动后需要运行的部分，
	// 而不是线程本身
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("这是 MyRunnable 的第 " + (i + 1) + " 次运行！");
		}
	}
}

package cn.ekgc.javasenior.day20210630.base;

public class Runnabletest {
	public static void main(String[] args) {
		Thread my01 = new Thread(new MyRunnable01());
		my01.start();
		for(int i = 0;i<10;i++) {
			System.out.println("这是main第"+(i+1)+"次运行");
			}
			}
		}

class MyRunnable01 implements Runnable{

	@Override
	public void run() {
		for(int i = 0;i<10;i++) {
			System.out.println("这是Runnable第"+(i+1)+"次运行");
			}
	}
}

package cn.ekgc.javasenior.day20210630.schedule;

public class JoinDemo {
	public static void main(String[] args) {
		// 创建 MyJoinThread 对象
		MyJoinThread joinThread = new MyJoinThread();
		// 设定当前线程名
		joinThread.setName("MyJoinThread");
		
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 main 线程的第 " + (i + 1) + " 次运行！");
			if (i == 5) {
				// 启动线程
				// 启动 MyJoinThread 线程
				joinThread.start();
				// 该线程启动后，直接加入运行，让 main 进入到等待阻塞中
				try {
					joinThread.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

class MyJoinThread extends Thread {
	@Override
	public void run() {
		// 获得当前线程名
		String name = Thread.currentThread().getName();
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 " + name + " 的第 " + (i + 1) + " 次运行！");
		}
	}
}

package cn.ekgc.javasenior.day20210630.schedule;

public class PriorityDemo {
	public static void main(String[] args) {
		// 创建 MyThread 对象
		MyPriorityThread myThread = new MyPriorityThread();
		// 对 myThread 线程进行命名
		myThread.setName("MyThread");
		
		// 在该线程启动前，可以调整线程的优先级别
		myThread.setPriority(10);
		// 启动 myThread 线程
		myThread.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 main 的第 " + (i + 1) + " 次运行！");
		}
	}
}

class MyPriorityThread extends Thread {
	@Override
	public void run() {
		// 获得当前线程的线程名
		String name = Thread.currentThread().getName();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 " + name + " 的第 " + (i + 1) + " 次运行！");
		}
	}
}

package cn.ekgc.javasenior.day20210630.schedule;

public class SleepDemo {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 main 的第 " + (i + 1) + " 次运行！");
			// 让 main 线程，每一轮循环都休眠 1s
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package cn.ekgc.javasenior.day20210630.schedule;

public class SortDemo {
	public static void main(String[] args) {
		int[] nums = {10, 2, 9, 1, 6, 5, 7};
		for (int i = 0; i < nums.length; i++) {
			SortThread sortThread = new SortThread(nums[i]);
			sortThread.start();
		}
	}
}

class SortThread extends Thread {
	private int num;
	
	public SortThread(int num) {
		this.num = num;
	}
	
	@Override
	public void run() {
		// 根据 num，让当前线程进行休眠
		try {
			Thread.sleep(num * 1000);
			System.out.println(num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package cn.ekgc.javasenior.day20210630.schedule;

public class YieldDemo {
	public static void main(String[] args) {
		// 创建 MyJoinThread 对象
		YieldThread yieldThread = new YieldThread();
		// 设定当前线程名
		yieldThread.setName("YieldThread");
		yieldThread.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 main 线程的第 " + (i + 1) + " 次运行！");
			// 每次输出完，都将 main 移出 CPU
			Thread.yield();
		}
	}
}

class YieldThread extends Thread {
	@Override
	public void run() {
		// 获得当前线程名
		String name = Thread.currentThread().getName();
		for (int i = 0; i < 10; i++) {
			System.out.println("这是 " + name + " 的第 " + (i + 1) + " 次运行！");
		}
	}
}