线程基础

最新推荐文章于 2022-08-04 11:17:09 发布

kangswx

最新推荐文章于 2022-08-04 11:17:09 发布

阅读量92

点赞数

分类专栏：并发编程文章标签：线程基础并发编程线程安全线程创建

本文链接：https://blog.csdn.net/kangswx/article/details/90489168

版权

并发编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

jps命令查看 pid
查看线程的堆栈： jstack pid
运行java监视和管理控制台： jconsole
并发编程的挑战
1. 硬件资源：带宽上传\下载速度、硬盘读写速度、cpu处理速度
2. 软件资源：数据库连接数、socket连接数、
进程与线程的区别
进程是系统进行分配和管理资源的基本单位
线程：进程的一个执行单元，是进程内调度的实例，是cpu调度和分派的基本单位，是比进程更小的独立运行的基本单位，线程也被称为轻量级进程，线程是程序执行的最小单位。
一个程序至少一个进程，一个进程至少一个线程。
进程有自己的独立地址空间，没启动一个进程，系统就会为他分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。
线程共享进程中的数据，使用相同的地址空间，因此cpu切换一个线程的花费远比进程要小的多，同时创建一个线程的开销也比进程要小的多。
线程之间的通信更加方便，同一个进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。
处理好同步与互斥是编写多线程程序的难点。
线程的状态及其相互转换
- 初始new: 新创建了一个线程对象，但还没有调用start方法。
- 运行Runnable：处于可运行状态的线程正在jvm中执行，但它可能正在等待来自操作系统的其他资源，如处理器。调用start后。
- 阻塞Blocked：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
- 等待(waiting): Object.wait(), join()。
- LockSupport.park(): 进入该状态的线程需要等待其他线程作出一些特定操作（通知或中断）。
- 超时等待(TIME_WAITING)：Object.wait(long), Thread.join(), LockSupport.parkNanos(), LockSupport.parkUntil, 该状态不同于WAITING，它可以在指定时间内自行返回。
- 终止(TERMINATE): 表示线程已经执行完毕。

创建一个线程，方式一继承Thread并重写run方法

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("name: "+Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.setName("MyThread");
        thread.start();
    }
}

创建一个线程，方式二实现Runnable接口，并实现run方法

public class MyRunnabe implements Runnable {

    @Override
    public void run() {
        System.out.println("name: "+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnabe());
        thread.setName("MyRunnabe");
        thread.start();
    }

}

实际开发中选第二种，
1. 因为java只允许单继承，但可以实现多个接口；
2. 增加程序的健壮性，代码可以共享，代码跟数据相对独立；
start和run的区别
- run只是方法的调用，程序依然在当前主线程
- start开启一个新线程

匿名内部类的方式启动一个线程

public class MyThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("name: "+Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}

Lambda的方式启动一个线程

public class Lambda {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("name: "+Thread.currentThread().getName());
        }).start();
    }
}

使用线程池启动一个线程

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            System.out.println("name: "+Thread.currentThread().getName());
        });
    }
}

线程的挂起：线程的挂去实质上就是使线程进入非可执行状态，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行。在线程挂起后可以通过重新唤醒唤醒线程实质恢复运行。
CPU分配的时间片很短，也很珍贵，挂起线程避免资源的浪费。

挂起线程的方式一（已废弃，不会释放所占有的资源，可能会引发死锁）

thread.suspend();   //挂起一个线程，已废弃, 不会释放所占有的资源，可能会引发死锁
thread.resume();    //唤醒一个线程,已废弃

线程的挂起和恢复

public class SuspendDemo implements Runnable{

    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(new SuspendDemo());
        thread.start();
        Thread.sleep(3000L);
        thread.resume();
    }

    @Override
    public void run() {
        System.out.println("开始name: "+Thread.currentThread().getName());
        Thread.currentThread().suspend();
        System.out.println("结束name: "+Thread.currentThread().getName());
    }
}

挂起可能会导致死锁

/**
 * 挂起会导致死锁
 */
public class DeadDemo implements Runnable{

    private static Object obj = new Object();

    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(new DeadDemo(), "对比线程");
        thread.start();
        Thread.sleep(1000L);
        thread.resume();

        Thread dead = new Thread(new DeadDemo(), "死锁线程");
        dead.start();
        //Thread.sleep(3000L);
        dead.resume();
    }

    @Override
    public void run() {
        //持有资源
        synchronized (obj) {
            System.out.println(Thread.currentThread().getName() +"持有资源");
            Thread.currentThread().suspend();
        }
        System.out.println(Thread.currentThread().getName() +"释放了资源");
    }
}

挂起线程的方式二

wait();       //暂停执行，放弃已经获得的锁，进入等待状态，可以使用
notify();     //可以使用
notifyAll();  //唤醒所有的线程

wait挂起线程

public class WaitDemo implements Runnable {

    private static Object waitObj = new Object();

    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(new WaitDemo(), "对比线程");
        thread.start();

        Thread thread2 = new Thread(new WaitDemo(), "对比线程2");
        thread2.start();
        thread2.sleep(3000L);

        synchronized (waitObj) {
            waitObj.notify();
        }
    }

    @Override
    public void run() {
        //持有资源
        synchronized (waitObj) {
            System.out.println(Thread.currentThread().getName() +"持有资源");
            try {
                waitObj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() +"释放了资源");
    }
}

什么时候使用线程：等待某些未就绪的资源，知道notify方法被调用。
线程的终端：

stop(被废弃，开发中不要使用，已调用线程立刻停止，有可能会导致响应的线程安全性问题)

public class UnsafeWithStop extends  Thread{

    private int i = 0;
    private int j = 0;

    @Override
    public void run() {
        i++;
        try {
            sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        j++;
    }

    public void print(){
        System.out.println("i: "+i);
        System.out.println("j: "+j);
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafeWithStop unsafeWithStop = new UnsafeWithStop();
        unsafeWithStop.start();
        Thread.sleep(1000L);
        unsafeWithStop.stop();
        unsafeWithStop.print();
    }
}

interrupt

/**
 * interrupt中断线程,打一个标志位，等待当前线程执行结束，不会立即终止
 */
public class InterruptDemo implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("name: "+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new InterruptDemo());
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

中断线程的第三种方式

/**
 * 设置标志位中断线程
 */
public class MyInterruptDemo implements Runnable {

    private static volatile boolean FLAG = true;

    @Override
    public void run() {
        while (FLAG){
            System.out.println("name: "+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyInterruptDemo());
        thread.start();
        Thread.sleep(1000L);
        FLAG = false;
    }
}

线程的优先级：线程的优先级告诉程序该线程的重要性，如果有大量的线程被阻塞，在等待运行，程序会尽可能先的执行优先级高的线程。

线程的优先级的值： 1到10，默认为5

public class PriorityDemo  {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true){
                System.out.println("name: "+Thread.currentThread().getName());
                /*try {
                    Thread.sleep(30L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
        }, "线程1");

        Thread thread2 = new Thread(() -> {
            while (true){
                System.out.println("name: "+Thread.currentThread().getName());
                /*try {
                    Thread.sleep(30L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
        }, "线程2");

        thread.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);

        thread.start();
        thread2.start();
    }
}

不同的平台对线程的优先级的支持不同，在编程的时候不要过度依赖线程优先级，如果程序运行正确取决于设置的优先级，那这样的程序是不正确的。
需要快速处理的，可以设置高的优先级，需要慢慢处理的，可以设置低的优先级。
线程分为用户线程和守护线程
- 用户线程：线程为执行完成之前，程序不会退出。
- 守护线程：尽量减少使用守护线程，因其不可控，不要在守护线程里进行读写操作，执行计算逻辑，

开启守护线程的方式

thread.setDaemon(true);  //在调用start之前
thread.start();

线程安全：当多个线程访问某个对象，不管运行时环境采用何种调度方式或者这些线程如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么这个类就成为线程安全的。
线程不安全：多个线程并发访问时，得不到正确的结果。