java 线程 总结

1.前言

（1）线程的上一级是进程，进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。
（2）线程与进程相似，但线程是一个比进程更小的执行单位，也被称为轻量级进程。一个进程在其执行的过程中可以产生多个线程。
（3）多线程就是多个线程同时运行或交替运行。
（4）提倡多线程而不是多进程 的原因是 线程间的切换和调度的成本远远小于进程。
（5）自定义线程可以继承Thread类 ，或者 实现Runnable接口 。
（6）多进程共享数据导致脏数据，可以使用同步锁 synchronized 解决。
（7）使用 interrupt() 和 return 配合 停止线程。
（8）不是优先级低的线程就一定在优先级高的线程后面运行，而是运行的机率会低一些，，反之亦然。
（9）线程分为用户线程和守护线程 ，当 用户线程 结束后，守护线程跟着结束 ，对于自定义线程可使用方法 setDaemon(true); 设置该线程为守护线程 。
　　常见的 守护线程是 垃圾回收线程
（10）开启线程的方式一共三种：Thread类、Runnable接口、callable接口

2.自定义线程

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

public class T1 {

    @Test
    public void t1(){
        //调用方法一
//        Mythread m = new Mythread();
//        m.start();


        //调用方法二
        MyRunnable mr = new MyRunnable();
        Thread thread=new Thread(mr);
        thread.start();
        System.out.println("结束");


    }


}

//方法一：
class Mythread extends Thread {
    @Override
    public void run(){
        super.run();
        System.out.println("我的线程");

    }

}

//方法二：
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("使用接口实现我的线程");
    }
}

3.多个线程之间不共享变量线程安全的情况

每个线程都有自己的实例变量count ,互不影响

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

/**
 * 多个线程之间不共享变量线程安全的情况
 */
public class T2 {

    @Test
    public void t2(){
        MyThread2 m1 = new MyThread2("1");
        MyThread2 m2 = new MyThread2("2");
        MyThread2 m3 = new MyThread2("3");
        m1.start();
        m2.start();
        m3.start();

    }

}

class MyThread2 extends Thread {
    private int count = 5;

    MyThread2(String name) {
//        super();
        //给父类的name属性赋值
        this.setName(name);
    }

    //每次new MyThread2只会执行一次run();
    @Override
    public void run() {
        super.run();
        while (count>0){
            System.out.println("由 线程 " + MyThread2.currentThread().getName() + " 计算，剩余count=" + count);
            count--;
        }
    }
}

/*
由 线程 1 计算，剩余count=5
由 线程 1 计算，剩余count=4
由 线程 1 计算，剩余count=3
由 线程 1 计算，剩余count=2
由 线程 1 计算，剩余count=1
由 线程 3 计算，剩余count=5
由 线程 2 计算，剩余count=5
由 线程 3 计算，剩余count=4
由 线程 3 计算，剩余count=3
由 线程 3 计算，剩余count=2
由 线程 3 计算，剩余count=1
由 线程 2 计算，剩余count=4
由 线程 2 计算，剩余count=3
由 线程 2 计算，剩余count=2
由 线程 2 计算，剩余count=1
 */

/*
每个线程都有自己的实例变量count ,互不影响
 */

4.共享数据的情况 [使用 同步锁 可解决脏数据问题]

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

/**
 * 共享数据的情况 [使用 同步锁 可解决脏数据问题]
 */
public class T3 {
    @Test
    public void t3() {
        MyThread3 myThread3 = new MyThread3();
        //参数分别是 自定义线程 ，线程名字
        Thread m1 = new Thread(myThread3, "1");
        Thread m2 = new Thread(myThread3, "2");
        Thread m3 = new Thread(myThread3, "3");
        Thread m4 = new Thread(myThread3, "4");
        Thread m5 = new Thread(myThread3, "5");
        m1.start();
        m2.start();
        m3.start();
        m4.start();
        m5.start();

    }
}

//class  MyThread3 extends Thread {
//    //公共数据
//    private int count = 5;
//    //每次new MyThread3只会执行一次run();
//    @Override
//    public  void run() {
//        super.run();
//        int yu = count--;
//        System.out.println("由 线程 " + MyThread3.currentThread().getName() + " 计算，剩余count=" + yu);
//
//    }
//}

/*
由 线程 3 计算，剩余count=2
由 线程 5 计算，剩余count=3
由 线程 1 计算，剩余count=5
由 线程 4 计算，剩余count=1
由 线程 2 计算，剩余count=4
 */

/*
本应该剩余count是依次递减的 ，可是显示是乱数据，
因为在大多数jvm中，count–-的操作分为如下三步：
取得原有count值
计算 -1 的结果
进行赋值
并发线程获取count的值显然是无法避免脏数据

 */

//使用锁 synchronized，即可解决线程脏数据
class  MyThread3 extends Thread {
    //公共数据
    private int count = 5;
    //每次new MyThread3只会执行一次run();
    //添加了同步锁 synchronized
    @Override
    public synchronized void run() {
        super.run();
        int yu = count--;
        System.out.println("由 线程 " + MyThread3.currentThread().getName() + " 计算，剩余count=" + yu);

    }
}
/*
由 线程 1 计算，剩余count=5
由 线程 5 计算，剩余count=4
由 线程 4 计算，剩余count=3
由 线程 3 计算，剩余count=2
由 线程 2 计算，剩余count=1
 */

5.使用 interrupt() 和 return 配合 停止线程

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

/**
 * 使用 interrupt() 和 return 配合 停止线程
 */

public class T4 {


    @Test
    public void t() throws InterruptedException {
        MyThread4 m = new MyThread4();
        m.start();
        //主线程休眠0.01秒后执行
        Thread.sleep(10);
        m.interrupt();
        Thread.sleep(1000);
        System.out.println("停了么？");

    }

}

class MyThread4 extends Thread {

    //每次new MyThread4只会执行一次run();
    @Override
    public  void run() {
        super.run();
        int i = 0;
        while (true) {
            //判断该线程是否被执行了interrupt()
            if (this.isInterrupted()) {
                System.out.println("线程被停止");
                return;
            }
            System.out.println(i++);
        }

    }
}

打印结果：

 

 

 6.线程优先级对比

setPriority不一定起作用的，在不同的操作系统不同的jvm上，效果也可能不同
数字越大优先级越高，但不是优先级低就一定在优先级高的线程后面运行，而是运行的机率会低一些，，反之亦然。

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

/**
 * 线程优先级对比
 * setPriority不一定起作用的，在不同的操作系统不同的jvm上，效果也可能不同
 * 数字越大优先级越高，但不是优先级低就一定在优先级高的线程后面运行，而是运行的机率会低一些，，反之亦然。
 *
 */
public class T5 {
    @Test
    public void t() {
        MyThread5 a = new MyThread5("A");
        MyThread5 b = new MyThread5("B");
//        a.setPriority(10);
//        b.setPriority(1);
        a.setPriority(1);
        b.setPriority(10);
        a.start();
        b.start();

    }

}

class MyThread5 extends Thread {

    MyThread5(String name) {
        super();
        this.setName(name);
    }

    @Override
    public  void run() {
        super.run();
        System.out.println("我是线程:" + Thread.currentThread().getName());
    }
}

 7.守护线程 ，当 用户线程 结束后，守护线程跟着结束 

注意：

不可使用@Test测试 ，否则所有线程都会随着用户线程结束而结束，看不到非守护线程运行效果

package com.example.javabaisc.myThread;

import org.junit.jupiter.api.Test;

/**
 * 守护线程 ，当 用户线程 结束后，守护线程跟着结束
 *
 * 不可使用@Test测试 ，否则所有线程都会随着用户线程结束而结束，看不到非守护线程运行效果
 *
 *
 */
public class T6 {

public static void main(String[] args) throws InterruptedException {
        MyThread6 a = new MyThread6();
        //设置该线程为守护线程
        a.setDaemon(true);
        a.start();
        Thread.sleep(1000);
        System.out.println("用户线程结束，退出，守护线程也跟着退出");


    }
}


class MyThread6 extends Thread {
    private int i = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println(i++);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }

    }
}

 

不设为守护线程的打印结果

 

 设为守护线程的打印结果