并发与多线程（一）

淩亂°似流年 2022-06-12 13:07 244阅读 0赞

（一）多线程  
多个线程共享单个CPU，线程之间竞争CPU资源。  
（二）多线程的优势  
如果采用单线程：当一个线程在等待用户输入数据时（即当前线程并没有使用CPU），其他线程也无法取得CPU资源，导致CPU大部分时间都是空闲的，CPU的利用率很低。

多线程则大大提高了CPU的利用率。多线程允许在输入文字的同时，打印或者保存文件。多线程可以使程序反应更快，交互性更强，执行效率更高。  
（三）创建任务与创建线程  
1）任务就是对象。为了创建任务，首先要定义一个任务类，实现了Runnable接口的类就是任务类。Runnable接口十分简单，只定义了一个run()方法。定义了一个任务类，就可以通过它的构造方法创建一个任务。代码示例：

//定义了一个任务类MyRunnerable
    public class MyRunnable implements Runnable { 
        @Override
        public void run() {
            //Runnable接口很简单，只定义了一个run()方法
            //必须要实现Runnable接口的run()方法
        }
    }

public static void main(String[] args) {
        //创建了一个任务
        Runnable runnable1=new MyRunnable();
    }

2）任务必须在线程中运行。Thread类中包括创建线程的构造方法、启动线程的方法、控制线程的方法。下面来看一下如何创建线程吧。

public static void main(String[] args) {
            //创建一个空的线程
            Thread thread1=new Thread();
    
            //创建了一个任务
            Runnable runnable1=new MyRunnable();
            //为一个任务创建一个线程
            Thread thread2=new Thread(runnable1);
    
        }

（四）实现多线程的2种方式  
方式一：实现Runnable接口的方式  
①定义任务类，实现Runnable接口，创建任务，为任务创建线程。该种方式就是上面采用的方式。  
②把任务作为构造参数传给Thread。当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {
            if (target != null) {
                target.run();
            }
        }

③代码示例：

//定义了一个任务类MyRunnerable
    public class MyRunnable implements Runnable { 
        @Override
        public void run() {
            for(int i=1;i<=1000;i++){
                System.out.println(i);
            }
        }
    }

public static void main(String[] args) {
            Runnable runnable=new MyRunnable();
            Thread thread=new Thread(runnable);
            thread.start();
        }

方式二：继承Thread类  
①因为Thread类实现了Runnable接口，所以，可以定义一个Thread类的继承类，并且重写run方法。然后在客户端程序中创建这个类的一个对象，并且调用它的start方法启动线程。  
②代码示例

//继承Thread类，重写run()方法
    public class MyThread extends Thread { 
        @Override
        public void run() {
            //
        }
    }

public static void main(String[] args) {
            MyThread thread=new MyThread();
            thread.start();
        }

③但是这种方式不推荐使用，因为它将任务和运行任务的机制混在了一起，任务就在线程之中。将任务从线程中分离出来是比较好的设计。推荐使用方式一。  
（五）线程的状态及状态转变  
1）线程有5种状态：新（初始）状态，就绪（可运行）状态，运行状态，阻塞状态，死亡状态。  
2）状态转变图  
![这里写图片描述][SouthEast]  
3）说明  
①新状态（初始状态）：线程对象已经创建，还没有调用它的start()方法  
②只有处于就绪状态的线程，才有机会获取CPU，从而进入到运行状态  
③处于阻塞状态的线程，没办法获取CPU，必须进入到就绪状态才能竞争CPU  
④Thread.sleep(long millis)能让当前正在运行的线程变成阻塞状态；Thread.yield()能让当前正在运行的线程变成就绪状态；join()能让当前线程进入到阻塞状态，直到该线程所加入的线程完成为止  
（六）认识Thread类  
1）常用的构造方法  
①Thread():创建一个空的Thread对象  
②Thread(Runnable target):为一个任务创建一个Thread对象  
③Thread(String name):创建任务时指定线程名，如果没有指定，则会自动为它生成线程名。每个线程都有线程名，线程名可以相同。  
④Thread(Runnable target, String name):指定线程名，指定任务  
2）一些简单方法（获取线程的相关信息）  
①public final String getName();//返回该线程的名称  
②public final void setName(String name);//修改线程名  
③public final int getPriority();//返回线程的优先级  
④public final void setPriority(int newPriority);//更改线程的优先级

Thread.MAX_PRIORITY等于10
        Thread.MIN_PRIORITY等于1
        Thread.NORM_PRIORITY等于5
        线程的默认优先级是5；修改线程的优先级时，必须保证优先级在1-10之间，否则会抛出IllegalArgumentException异常；数字越大，优先级越大。

⑤public String toString();//返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

public String toString() {
            ThreadGroup group = getThreadGroup();
            if (group != null) {
                return "Thread[" + getName() + "," + getPriority() + "," +
                               group.getName() + "]";
            } else {
                return "Thread[" + getName() + "," + getPriority() + "," +
                                "" + "]";
            }
        }

3）控制线程的方法  
①public void start();//使该线程开始执行；Java 虚拟机调用该线程的 run 方法。  
注意，1个线程只能启动1次。当一个线程已经启动了，不能再次启动。特别是当线程已经执行结束了，不得重新启动。  
②public final boolean isAlive();//判断线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态，返回true  
③public final void join();//让当前线程等待该线程终止

public static void main(String[] args) throws InterruptedException {
            Runnable runnable1=new MyRunnable();
            Thread thread2=new Thread(runnable1);
            thread2.start();//启动线程
    
            for(int i=1;i<=100;i++){
                System.out.println(i);
                if(i==50){
                    //当i==50时，让主线程main等待thread2终止
                    //主线程要等thread2执行完成后，再去执行
                    thread2.join();
                }
            }
        }

④public final void join(long millis);//等待该线程终止的时间最长为 millis 毫秒  
⑤public static void sleep(long millis);//让当前正在执行的线程休眠millis毫秒  
让当前线程休眠（当前线程进入到阻塞状态），让出CPU，那么其他线程就可以获得CPU。

public static void main(String[] args) throws InterruptedException {
            Runnable runnable1=new MyRunnable();
            Thread thread2=new Thread(runnable1);
            thread2.start();//启动线程
    
            for(int i=1;i<=100;i++){
                System.out.println(i);
                if(i==10){
                    //当i等于10，让当前线程休眠5s。那么thread2将会获得CPU
                    Thread.sleep(5000);
                }
            }
        }

当前线程执行了sleep(long millis)方法后，将转到阻塞状态。等待millis毫秒后，睡眠结束，会进入到就绪状态。  
⑥public static Thread currentThread();//返回对当前正在执行的线程对象的引用，获取当前线程  
⑦public static void yield();//暂停当前正在执行的线程对象  
让当前正在执行的线程放弃CPU，转为就绪状态。相同优先级或者更高优先级的线程将有机会获得CPU。  
yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。  
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以不一定能观察到效果。  
⑧public static boolean interrupted();//判断当前线程是否已经中断  
⑨public void interrupt();//中断线程  
⑩public boolean isInterrupted();//判断线程是否已经中断

[SouthEast]: /images/20220612/05c0aba8d0b249cd88c37a7de4ee75f0.png