尚硅谷_每日一考_427
427
1.谈谈你对程序、进程、线程的理解。
程序：programm，为完成某个任务，采用某种编程语言编写的一组命令的集合，是一段静态代码。
进程：process，正在运行的程序。如运行中的wechat等，有一个生命周期。
线程：thread，一个程序内部的执行路径。
例如，360软件，启动后，程序运行，其中每一个功能代表一个线程，表明该软件是支持多线程的。
重点：如何创建多线程
2.代码完成继承 Thread 的方式创建分线程，并遍历100 以内的自然数。
//步骤
//1.创建一个继承于thread的子类
class Mythread extends Thread{
//2.重写Thread的run()方法-->将此线程执行的操作声明在run()中
public void run(){
for(int i = 0; i < 100; i++){//自然数是指非负整数
System.out.println(i);
}
}
}
public class ThreadTest{
public static void mian(String[] args){
//3.创建Thread类的子类
Mythread t1 = new MyThread();//mian方法，主线程做的
//4.通过此对象调用start
t1.start();//Thread中的方法，start方法会自动调用执行run()方法，t1开始独立执行|1.启动当前线程2.调用当前线程的run(),已重写的
}
}
3.代码完成实现Runnable 接口的方法创建分线程，并遍历 100以内的自然数。
/*1.创建一个类实现Runnable接口
2.重写run方法
3.创建类的实例
4.将实例对象传入Thread类的构造器，并创建新的线程对象
5.用该对象调用start方法。启动线程，并调用run方法，从Thread的源码可知，该方法调用了Runnable类型的target的run()
*/
class Mythread implements Runnable{
public void run(){
for(int i = 0; i < 100; i++){
System.out.println(i);
}
}
}
public class Mythread{
public static void main(String[] args){
Mythread myThread = new Mythread();
Thread t1 = new Thread(MyThread);
t1.start();
}
}
4.对比两种创建方式。
1.都重写run方法
2.用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限；
3.用实现Runnable接口的方法，可以实现多个线程共享同一段代码(数据，如买票时的票数)；
MyThread myThread = new MyThread();
MyThread t1 = new Thread(myThread);
MyThread t2 = new Thread(myThread);
4.程序有同步逻辑需求，则使用Runnable的方法来创建线程。
5.说说你对 IDEA 中Project 和Module 的理解。
对应Eclipse中的WorkSpace和Project
线程创建方法详解
1.继承Thread
//步骤
//1.创建一个继承于thread的子类
class Mythread extends Thread{
//2.重写Thread的run()方法-->将此线程执行的操作声明在run()中
public void run(){
for(int i = 0; i < 100; i++){//自然数是指非负整数
System.out.println(i);
}
}
}
public class ThreadTest{
public static void mian(String[] args){
//3.创建Thread类的子类
Mythread t1 = new MyThread();//mian方法，主线程做的
//4.通过此对象调用start
t1.start();//Thread中的方法，start方法会自动调用执行run()方法，t1开始独立执行|1.启动当前线程2.调用当前线程的run(),已重写的
t1.run();//不可以的，没有启动新线程,还是main
//可以调用获取当前线程名的方法查看，Thread.currentThread().getName()
t1.start();//两次调用，该方法会抛异常
//可以新建线程对象
Mythread t2 = new MyThread();
t2.start();
for(int j = 0; j<=100; j++){
System.out.println("helloWorld")//主线程执行的，与上条语句共同争夺线程CUP
}
}
}
创建Thread类的匿名子类的方式
new Thread(){
public void run(){
for(int i = 0; i <= 100; i++){//自然数是指非负整数
System.out.println(i);
}
}
}.start();
2.实现runnable接口
//1.创建一个实现了Runnable接口的类
class MyThread implements Runnable{
//2.实现 类去实现Runnable中的方法：run()
public void run(){
for(int i = 0; i<100; i++){
System.out.println(i);
}
}
}
public class MyThread{
public static void main(String[] args){
//3.创建实现类的对象
MyThread myThread = new MyThread();
//4.将此对象作为参数传到Thread类的构造器中，创建Thread类的对象
MyThread t1 = new Thread(myThread);
//5.通过Thread类的对象调用start()。调用了Runnable类型的target的run()
t1.start();
}
}
拓展
创建线程的方式3：实现 Callable 接口。
特点：
1.与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
2.Callable需要依赖FutureTask，用于接收运算结果。一个产生结果，一个拿到结果。3.
FutureTask是Future接口的实现类，也可以用作闭锁。
异同：
（1）Callable规定的方法是call()，而Runnable规定的方法是run().
（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
（3）call()方法可抛出异常，而run()方法是不能抛出异常的。
（4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果
public class MyCallable implements Callable<Integer> {
public Integer call() {
return 666;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable myThread = new MyCallable();
FutureTask<Integer> ft = new FutureTask<>(myThread);
Thread t1 = new Thread(ft);
t1.start();
System.out.println(ft.get());
}
参考文章链接：https://blog.csdn.net/qq_42253147/article/details/94330841