Java之多线程

程序、进程和线程的概念：

程序：为完成特定任务，用某种语言编写的一组指令的集合。即一段静态的代码，静态的对象。

进程：是程序的一次执行过程，或是正在运行的一次程序。是一个动态的过程，有产生、存在和消亡的过程--------生命周期。

如运行中的QQ、运行中的mp3。程序是静态的，进程是动态的。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径。

（1）若一个进程同一时间并行多个线程就是支持多线程的。

（2）线程作为调度和执行的单位，每个线程拥有独立的虚拟机栈和程序计数器，线程切换的开销小。

（3）一个进程中的多个线程共同享用堆和方法区，从这些区域可以访问相同的变量和对象，使得线程间的通信高效，但是多个线程共享系统资源也会带来安全隐患。

单核和多核CPU：单核CPU通过快速地切换多个线程执行，而多核CPU可以直接每个核心就执行某个线程不需要切换，多核的话才能更好地发挥多线程的效果。

一个JAVA的应用程序至少有三个线程在同时运行，main线程、GC线程和异常处理的线程。

并行与并发：

并行：多个CPU执行多个任务

并发：一个CPU（采用时间片轮询）同时执行多个任务

使用多线程的优点：以单核CPU为例，只使用单线程执行多个任务（如调用多个方法）比多线程来完成用的时间更短，为何还需多线程？

多线程的优点：

（1）提高应用程序的响应，对图形化界面更有意义，增加用户体验。

（2）提高计算机CPU的使用率

（3）改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

何时需要多线程？

（1）程序需要同时执行两个以上的任务

（2）程序需要实现一些等待的任务，如用户输入、文件读写、网络操作等

（3）需要一些后台运行的程序

线程的创建和使用：

方法一：

（1）创建一个Thread类的子类

（2）在子类里面重写run()方法---->将想要此线程执行的操作放在run()方法里面

（3）创建一个子类的对象 

  4）通过该子类对象调用start()方法启动线程。

  start()方法的两个作用：（1）启动该线程（2）调用该线程的run()方法

package com.sf.javaLearningThread;

import org.junit.Test;
/*
创建多线程的方法

方法一：
（1）创建一个Thread类的子类
（2）在子类里面重写run()方法---->将想要此线程执行的操作放在run()方法里面
（3）创建一个子类的对象
（4）通过该子类对象调用start()方法启动线程。
start()方法的两个作用：（1）启动该线程（2）调用该线程的run()方法

方法二：
 */
class MyThread extends Thread{

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(i + "***" + Thread.currentThread().getName());
            }
        }
    }
}

public class BulidThread01 {

    @Test
    public void test01(){
        MyThread myThread = new MyThread();
        //问题一：我们不能直接通过调用run()方法来启动一个线程；直接调用run()时这还是在主线程里面，没有新开一个线程。
        //myThread.run();
        myThread.start();
        //问题二：我们需要重新创建一个线程的对象，才能开始另一个新线程,不能直接再次调用start()，这样会报错
        MyThread myThread1 = new MyThread();
        myThread1.start();

        //如下操作仍然是在主线程中执行的
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(i + "*****" + Thread.currentThread().getName());
            }
        }
    }
}

可以考虑匿名内部类或者lamda表达式的写法来重写run()方法

package com.sf.javaLearningThread;

import org.junit.Test;

class MyThread1 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 50; i++){
            if(i % 2 == 0){
                System.out.println(i + "**" +Thread.currentThread().getName());
            }
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 50; i++){
            if(i % 2 != 0){
                System.out.println(i + "**" +Thread.currentThread().getName());
            }
        }
    }
}

public class TestThread01 {
    @Test
    public void test01(){
        //这样写显得有些冗余，可以考虑匿名内部类或者lamda表达式的写法
//        MyThread1 myThread1 = new MyThread1();
//        myThread1.start();
//
//        for(int i = 0; i < 20; i++){
//            System.out.println(i + "**" +Thread.currentThread().getName());
//        }
//
//        MyThread2 myThread2 = new MyThread2();
//        myThread2.start();

        //匿名内部类
        new Thread(){
            @Override
            public void run() {
                for(int i = 0; i < 50; i++){
                    if(i % 2 == 0){
                        System.out.println(i + "**" +Thread.currentThread().getName());
                    }
                }
            }
        }.start();

       //lamda表达式
        new Thread(() -> {
            for(int i = 0; i < 50; i++){
                if(i % 2 != 0){
                    System.out.println(i + "**" +Thread.currentThread().getName());
                }
            }
        }).start();
    }
}

Thread里面常用的方法
（1）start():启动当前线程并调用当前线程的的run()方法
（2）run()：通常需要重写Thread类中的此方法，将创建的线程需要执行的操作放在该方法里面
（3）currentThread()：静态方法，返回执行当前代码的线程
（4）getNmame()：获取当前线程的名字
（5）setName()：设置当前线程的名字
（6）yield():释放当前cpu的执行权
（7）join():在线程a中调用线程b的join()方法，此时线程a进入阻塞状态直到线程b完全执行完成之后，线程a才结束阻塞状态。

package com.sf.javaLearningThread;

import org.junit.Test;
/*
Thread里面常用的方法
（1）start():启动当前线程并调用当前线程的的run()方法
（2）run()：通常需要重写Thread类中的此方法，将创建的线程需要执行的操作放在该方法里面
（3）currentThread()：静态方法，返回执行当前代码的线程
（4）getNmame()：获取当前线程的名字
（5）setName()：设置当前线程的名字
（6）
（7）
 */
class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 50; i++){
            if(i % 2 == 0){
                System.out.println(i + "**" +Thread.currentThread().getName());
            }
        }
    }

    public HelloThread(String name){
        super(name);
        //Thread.currentThread().setName(name);

    }
}

public class TestThreadMethods {
    @Test
    public void test(){
        Thread.currentThread().setName("main-Thread");
        HelloThread helloThread = new HelloThread("Thread-1");

        for(int i = 0; i < 50; i++){
            if(i % 2 == 0){
                System.out.println(i + "**" +Thread.currentThread().getName());
            }
        }

        helloThread.start();
    }
}

package com.jinjian;

import org.junit.Test;

/**
 join():在线程a中调用线程b的join()方法，此时线程a进入阻塞状态直到线程b完全执行完成之后，线程a才结束阻塞状态。
 */
public class ThreadTest01 {
    @Test
    public void test() throws InterruptedException {
        Thread t = new Thread(() ->{
            for(int i = 0; i < 50; i++){
                if(i % 2 != 0){
                    System.out.println(i + "**" +Thread.currentThread().getName());
                }
            }
        });
        t.start();
        for(int i = 0; i < 10; i++){
            if(i > 5){
                System.out.println(t.isAlive());
                t.join();
            }
            System.out.println(i + "**" +Thread.currentThread().getName());
        }

        //System.out.println(t.isAlive());
        //System.out.println(Thread.currentThread().isAlive());
    }
}

sleep(long millitime)方法：让当前线程睡眠指定的时间long millitime，在指定的时间long millitime内当前线程是阻塞的。
主线程必须在子线程之后结束，这样子线程才能继续执行。

线程的优先级：
MAX_PRIORITY：10  MIN_PRIORITY：1   NORMAL_PRIORITY：5  默认的优先级
如何获取和设置当前线程的优先级：
获取：Thread.currentThread().getPriority()
设置：Thread.currentThread().setPriority(MAX_PRIORITY)

说明：高优先级的线程要抢占低优先级线程cpu的执行权，将线程的优先级调高后从概率上来说要比低优先级的线程要先运行，但是并不意味着高优先级的线程执行完后低优先级的线程才会执行。

package com.jinjian;

import org.junit.Test;

import static java.lang.Thread.MAX_PRIORITY;
import static java.lang.Thread.MIN_PRIORITY;
import static java.lang.Thread.sleep;

/**
 sleep(long millitime)方法：让当前线程睡眠指定的时间long millitime，在指定的时间long millitime内当前线程是阻塞的。
 主线程必须在子线程之后结束，这样子线程才能继续执行。

 线程的优先级：
 MAX_PRIORITY：10  MIN_PRIORITY：1   NORMAL_PRIORITY：5  默认的优先级
 如何获取和设置当前线程的优先级：
 获取：Thread.currentThread().getPriority()
 设置：Thread.currentThread().setPriority(MAX_PRIORITY)

 说明：高优先级的线程要抢占低优先级线程cpu的执行权，将线程的优先级调高后从概率上来说要比低优先级的线程
 要先运行，但是并不意味着高优先级的线程执行完后低优先级的线程才会执行。
 */

public class ThreadTest {

    @Test
    public void test() throws InterruptedException {
        new Thread(() ->{
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            Thread.currentThread().setPriority(MAX_PRIORITY);
                System.out.println("ThreadcurrentThread().getName() : " + Thread.currentThread().getName() + "  ,Thread.currentThread().getPriority() : " + Thread.currentThread().getPriority());
        }).start();

           Thread.currentThread().setPriority(MIN_PRIORITY);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadcurrentThread().getName() : " + Thread.currentThread().getName() + "  ,Thread.currentThread().getPriority() : " + Thread.currentThread().getPriority());


    }

}

创建线程的方法二：

(1)创建一个实现了Runnable接口的类

(2)实现类去实现Runnable中的抽象方法：run()

(3)创建实现类的对象

(4)将此对象作为参数传递到Thread类的构造器里面，创建Thread类对象

(5)通过Thread类创建对象调用start()方法

//(1)创建一个实现了Runnable接口的类
class MyThread implements Runnable{
    @Override
    // (2)实现类去实现Runnable中的抽象方法：run()
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println(i + "**" +Thread.currentThread().getName());
        }
    }
}

public static void main(String[] args) {
    //创建实现类的对象
    MyThread myThread = new MyThread();
    //将此对象作为参数传递到Thread类的构造器里面，创建Thread类对象
    new Thread(myThread).start();
}