Java 多线程

JAVA 多线程

多任务的概念：
当今的操作系统绝大部分都是基于多任务的操作系统；
多任务操作系统的最大特点，是可以同时运行多个程序；
由于操作系统支持时间片轮换算法，使得用户感觉多个程序在同时运行，似乎有多个CPU在起作用。

线程的概念：
运行在操作系统之上的每个应用程序，都会占用一个独立的进程（process），而进程内又允许运行多个线程（thread），这意味着一个程序可以同时执行多个任务的功能；
在基于线程的多任务而处理环境中，线程是执行特定任务的可执行代码的最小单位；
多线程帮助你写出CPU最大利用率的高效程序，因为空闲时间保持最低，这对Java运行的交互式的网络互连环境是至关重要的，例如：网络的数据传输速率远低于计算机的处理能力，在传统的单线程环境中，你的计算机必须花费大量的空闲时间来等待，多线程能够使你充分利用这些空闲时间。
一个程序下有多个进程（分属于不同模块），一个进程之下会做很多事情(线程）
多线程意味着多任务

多线程的优点:
Java支持编写多线程的程序；
多线程最大的好处在于可以同时并发执行多个任务，当程序的某个功能部分正在等待某些资源的时候，此时又不愿意因为等待而造成程序暂停，那么就可以创建另外的线程进行其它的工作；
多线程可以最大限度地减低CPU的闲置时间，从而提高CPU的利用率；

进程与线程的区别：
进程是指系统中正在运行中的应用程序，它拥有自己独立的内存空间；
线程是指进程中一个执行流程，一个进程中允许同时启动多个线程，他们分别执行不同的任务；
线程与进程的主要区别在于：每个进程都需要操作系统为其分配独立的内存地址空间，而同一进程中的所有线程在同一块地址空间中，这些线程可以共享数据，因此线程间的通信比较简单，消耗的系统开销也相对较小。

在Java中实现线程有两种方式，分别是：
扩展java.lang.Thread类
实现java.lang.Runnable接口

java.lang.Thread类用于创建和操作线程，其中包括几个很重要的静态方法，用于控制当前线程：

方法原型	说明
static Thread currentThread()	返回对当前正在执行的线程对象的引用
static void sleep(long millis)throws InterruptedException	让当前正在执行的线程休眠（暂停执行），休眠时间由millis（毫秒）指定
static void sleep(long millis, int nanos)throws InterruptedException	让当前正在执行的线程休眠，休眠时间由millis（毫秒）和nanos（纳秒）指定
static void yield()	暂停当前正在执行的线程，转而执行其它的线程
static boolean interrupted()	判断当前线程是否已经中断

任何一个Java程序启动时，一个线程立刻运行，它执行main方法，这个线程称为程序的主线程；
也就是说，任何Java程序都至少有一个线程，即主线程；
主线程的特殊之处在于：
它是产生其它线程子线程的线程；
通常它必须最后结束，因为它要执行其它子线程的关闭工作

在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法

编写一个名为FirstThread类

public class FirstThread extends Thread {

        //开辟线程，想要将代码放入到小线程运行前提：你要在小线程中运行的代码必须放到固定方法中
    @Override
    public void run() {//线程的主要方法，但是并不意味着小线程开启
        for (int i =0; i< 10;i++){
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

编写测试类

public class Test {
    public static void main(String[] args) {
//        for (int i =30; i<40; i++){
//            try {
//                Thread.currentThread().sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(i);
//        }
        FirstThread ft = new FirstThread();//线程对象
        ft.setName("线程1");
        FirstThread ft1 = new FirstThread();
        ft1.setName("线程2");
       // ft.run();//只运行了线程的主要方法，并没有开启线程
        //线程想要运行，只能由CPU决定，不可以规定某个线程一定获取cpu
        //ft和ft1优先级是一样的，而main方法优先级是最高的，所以会先运行main方法中的for循环再运行ft中的for循环
        ft.setPriority(6);//设置优先级,更高的优先级不意味着就能优先获取到cpu，只是说机会会更大一点
        ft1.setPriority(1);
        ft.start();//开启线程->就绪状态(还没有运行) 获取到了cpu->运行状态(run方法)
        ft1.start();
    }
}

测试结果：

线程1:0
线程2:0
线程1:1
线程2:1
线程1:2
线程2:2
线程1:3
线程2:3
线程1:4
线程2:4
线程1:5
线程2:5
线程1:6
线程2:6
线程1:7
线程2:7
线程1:8
线程2:8
线程1:9
线程2:9

Process finished with exit code 0

线程优先级
实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；
优先级较高的线程有更多获得CPU的机会，反之亦然；
优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；
Thread类有如下3个静态常量来表示优先级：
MAX_PRIORITY：取值为10，表示最高优先级
MIN_PRIORITY：取值为1，表示最底优先级
NORM_PRIORITY：取值为5，表示默认的优先级

线程状态：
新建状态（New）：使用new关键字创建线程对象，仅仅被分配了内存；
就绪状态（Ready）：线程对象被创建后，等待它的start方法被调用，以获得CPU的使用权；
运行状态（Running）：执行run方法，此时的线程的对象正占用CPU；
睡眠状态（Sleeping）：调用sleep方法，线程被暂停，睡眠时间结束后，线程回到就绪状态，睡眠状态的线程不占用CPU；
死亡状态（Dead）：run方法执行完毕后，线程进入死亡状态；
阻塞状态（Blocked）：线程由于某些事件（如等待键盘输入）放弃CPU，暂停运行，直到线程重新进入就绪状态，才有机会转到运行状态；

线程在它的生命周期中会处于不同的状态：java.lang.Runnable接口中仅仅只有一个抽象方法：
public void run();
也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；
Runnable接口的存在主要是为了解决Java中不允许多继承的问题；
使用Runnable接口可以使语法的自由度更高。

//线程的预备类
public class ScecondThread implements Runnable {

    @Override
    public void run() {
        for(int i =0; i< 10; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

package com.student.study;

public class Test2 {
    public static void main(String[] args) {
        //Runable r = new SeccondThread();//多态
        ScecondThread st = new ScecondThread();
        Thread t = new Thread(st);
        ScecondThread st1 = new ScecondThread();
        Thread t1 = new Thread(st1);
        t.setName("线程1");
        t1.setName("线程2");
        t.start();
        t1.start();
        //虽然控制不了cpu的调用，但是可以将单一线程变为多线程
    }
}

测试结果：

线程1:0
线程1:1
线程1:2
线程1:3
线程2:0
线程1:4
线程2:1
线程2:2
线程2:3
线程2:4
线程2:5
线程2:6
线程2:7
线程2:8
线程2:9
线程1:5
线程1:6
线程1:7
线程1:8
线程1:9

使用内部类的方法

public class Test3 {
    public static void main(String[] args) {
        //类部类的方法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+i);

                }
            }

        };
        Thread t =new Thread(r1);
        Thread t1 =new Thread(r1);
        t.start();
        t1.start();
    }
}

测试结果：

Thread-1:0
Thread-0:0
Thread-1:1
Thread-0:1
Thread-0:2
Thread-1:2
Thread-0:3
Thread-1:3
Thread-0:4
Thread-1:4
Thread-0:5
Thread-1:5
Thread-0:6
Thread-1:6
Thread-0:7
Thread-1:7
Thread-0:8
Thread-1:8
Thread-0:9
Thread-1:9

Process finished with exit code 0