java进阶打卡16

主线程

主线程：执行主（main）方法的线程

单线程程序：java程序中只有一个线程
执行从main方法开始，从上到下依次执行

JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条main方法通向cpu的执行路径，
cpu就可以通过这个路径来执行main方法，而这个路径有一个名字，叫【main(主)线程】。

创建多线程程序的第一种方式：创建Thread类的子类

java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：
1. 创建一个Thread类的子类
例如：	public class MyThread extends Thread{}

2. 在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
例如：	@Override
    	public void run() {
    		...
		}
		
3. 创建Thread类的子类对象
例如：	MyThread mt = new MyThread();

4. 调用Thread类中的方法start方法，开启新的线程，执行run方法
	void start() 使该线程开始执行；Java虚拟机调用该线程的run方法。
例如：	 mt.start();
	
    结果使两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程，执行run方法）。
    多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行。

多线程原理

程序执行的结果：随机性打印

JVM执行main方法，找OS（操作系统）开辟一条main方法通向cpu的路径，这个路径叫main线程，主线程
cpu通过这个线程，这个路径可以执行main方法

开辟一条通向cpu的新路径，用来执行run方法

对于cpu而言，就有了两条执行的路径，cpu就有了选择的权力，cpu喜欢谁，就会执行哪个路径，我们控制不了，所以就有了程序的随机打印结果
两个线程，一个main线程，一个新线程一起抢夺cpu的执行权（执行时间），谁抢到了谁执行对应的代码

main方法：
MyThread mt = new MyThread();
mt.run()；		单线程、main线程
【mt.start();】	开辟新的栈空间，执行run方法

run方法：
for循环

cpu就有了选择的权利，可以执行main方法，也可以执行两个run方法
多线程的好处：多个线程之间互不影响（在不同的栈空间）

Thread类的常用方法

• 获取线程的名称

1. 使用Thread类中的方法getName()
	String getName() 返回该线程的名称。
例如：	String name = getName();
	
2. 可以先获取到当前正在执行的线程，再使用线程中的方法getName()获取线程的名称
	static Thread currentThread() 返回对当前正在执行的线程对象的引用。
例如：	Thread t = Thread.currentThread();
		String name = t.getName();

//链式编程
System.out.println(Thread.currentThread().getName());	

• 设置线程的名称（了解）

1. 使用Thread类中的方法setName（名字）
	void setName(String name) 改变线程名称，使之与参数name相同。
例如：	MyThread mt = new MyThread();
        mt.setName("小强");

2. 创建一个带参数的构造方法，参数传递线程的名称；调用分类的带参构造方法，把线程名称传递给父类，让父类（Thraed）给子线程起一个名字
	Thread(String name) 分配新的Thread对象
	
例如：	
public class MyThread extends Thread{
	public MyThread() {}
	public MyThread(String name) {
        super(name);//把线程名称传递给父类，让父类（Thraed）给子线程起一个名字
    }
    @Override
    public void run() {...}
}   
main方法：
 new MyThread("旺财").start(); // 开启多线程

• sleep

public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
毫秒数结束之后，线程继续执行

// 使用Thread类的sleep方法让程序睡眠1秒钟
try {
	Thread.sleep(1000);
} catch (InterruptedException e) {
	e.printStackTrace();
}

创建多线程程序的第二种方式：实现Runnable接口

java.lang.Runnable
    Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个名称为run的无参方法。
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的Thread对象
    Thread(Runnable target, String name) 分配新的Thread对象

实现步骤：
1. 创建一个Runnable接口的实现类
例如：	public class RunnableImpl implements Runnable{}
2. 在实现类中重写Runnable接口的run方法，设置线程任务
例如：	@Override
    	public void run() {...}    	
3. 创建一个Runnable接口的实现类对象
例如：	RunnableImpl run = new RunnableImpl();
4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
例如：	Thread t = new Thread(run);
		Thread t = new Thread(new RunnableImpl2()); // 3.4步合并
5. 调用Thread类中的start方法，开启新的线程执行run方法
例如：	t.start();

实现Runnable接口创建多线程程序的好处：
1. 避免了单继承的局限性
	一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其他的类
	实现了Runnable接口，还可以继承其他的类，实现其他的接口
2. 增强了程序的扩展性，降低了程序的耦合性（解耦）
	实现Runnable接口的方法，把设置线程任务和开启新线程进行了分离（解耦）
	实现类中，重写了run方法：用来设置线程任务
	创建Thraed类对象，调用start方法：用来开启新线程	

创建多线程程序的第三种方式：实现Callable接口

java.util.concurrent.Callable

实现步骤：
1. 创建一个Callable接口的实现类
例如：	public class CallableImpl implements Callable {}
2. 在实现类中重写Callable接口的call方法，设置线程任务
例如：	@Override
    	public Object call() throws Exception {
	    	...
	    	return xxx;
    	}
3. 创建一个Callable接口的实现类对象
例如：	CallableImpl ci = new CallableImpl();
4. 创建FutureTask类对象,构造方法中传递Callable接口的实现类对象
例如：	FutureTask<Integer> ft = new FutureTask<>(ci);
5. 创建Thread类对象，构造方法中传递FutureTask类对象
例如：	Thread t = new Thread(ft);
6. 调用Thread类中的start方法，开启新的线程执行run方法
例如：	t.start();

实现Callable接口创建多线程程序的好处：
除了与Runnable相同的优势外，Callable独有的优势是call方法有返回值。