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

热门相关:最强狂兵   霸皇纪   霸皇纪   天启预报   刺客之王