尚硅谷_每日一考_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