预习java线程

线程

线程，是一个进程内部的最小执行单元；
1.线程和进程的关系：
（1）一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行；
（2）每一个进程至少包含一个线程（称为主线程），在主线程中开始执行程序，java程序的入口main()方法就是在主线程中被执行的；
（3）在主线程中可以创建并启动其他的线程；
（4）一个进程内所有的线程共享该进程的内存资源。
2.多线程：
（1）概念：多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行的线程来完成各自的任务。
（2）何时需要多线程：

1. 程序需要同时执行两个或多个任务；
2. 程序需要实现一些需要等待的任务时，eg：用户输入、文件读写操作、网络操作、搜索等；
3. 需要一些后台运行的程序时。

（3）多线程的优点：

1. 提高程序响应；
2. 提高CPU的利用率；
3. 改善程序结构，将复杂任务分为多个线程，独立运行。

（4）多线程的缺点：

1. 线程也是程序，所以线程需要占用内存，线程越多占用内存越大；
2. 多线程需要协调和管理，所以需要CPU时间跟踪线程；
3. 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题。

2.创建线程
（1）继承Thread类的方式：
1.定义子类继承Thread类；
2.子类中重写Thread类中的run方法；
3.创建Thread子类对象，即创建了线程对象；
4.调用线程对象start方法，启动线程，调用子类中的run方法。

public class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

（2）实现Runnable接口的方式：
1.定义子类实现Runnable接口；
2.子类中重写Runnable接口中的run方法；
3.通过Thread类含参构造方法创建线程对象；
4.将实现Runnable接口的子类对象作为实际参数传递给Thread类的构造器中；
5.调用Thread类的start方法，开启线程，调用Runnable子类接口的run方法。

public class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

public class TestDemo1 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        myThread1.setName("t1");
        myThread1.start();//MyThread1

        Thread thread = new Thread(new MyThread2(),"t2");
        thread.start();//MyThread2
    }
}

3.Thread类中的构造方法：
（1）Thread(): 创建一个新的线程；
（2）Thread(String name):创建一个指定名称的线程；
（3）Thread(Runnable target):利用Runnable对象创建一个线程，启动时将执行该对象的run方法；
（4）Thread(Runnable target,String name):利用Runnable对象创建一个指定名称的线程。
4.Thread类中的常用方法：
（1）void start()
启动线程；
（2）final void setName(String name)
设置线程的名称；
（3）final String getName()
返回线程的名称；
（4）final void setPriority(int new Priority)
设置线程优先级；
（5）final int getPriority()
返回线程优先级；
（6）final void join() throws InterruptedException
等待进程终止；
（7）static Thread currentThread()
返回对当前正在执行的线程对象的引用；
（8）static void sleep(long millis) throws InterruptedException
让当前正在执行的线程休眠（暂停执行），休眠时间由毫秒为单位。

public class TestDemo1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 myThread1 = new MyThread1();
        myThread1.setName("t1");
        myThread1.setPriority(2);
        System.out.println(myThread1.getPriority());
        myThread1.start();//MyThread1
        Thread thread = new Thread(new MyThread2(),"t2");
        thread.setPriority(1);
        thread.sleep(1000L);
        System.out.println(thread.getPriority());
        thread.start();//MyThread2
        System.out.println(thread.currentThread());
        /*
        * 2
        MyThread1
        1
        Thread[main,5,main]
        MyThread2*/
    }
}

5.继承方式和实现方式的联系与区别：
（1）区别
继承Thread：线程代码存放Thread子类的run方法中；
实现Runnable：线程代码存在接口的子类的run方法。
（2）实现Runnable的好处：

1. 避免了单继承的局限性；
2. 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一分资源。

标签：Runnable,java,Thread,子类,void,预习,线程,MyThread1
来源： https://blog.csdn.net/weixin_45649686/article/details/110929097