java 多线程

最新推荐文章于 2024-09-25 10:59:43 发布

qq_46146522

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量430

点赞数

分类专栏： javase 文章标签： java jvm 面试

本文链接：https://blog.csdn.net/qq_46146522/article/details/126445018

版权

javase 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

什么是线程？

进程：是系统进行分配和管理资源的基本单位

线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。

一个程序至少一个进程，一个进程至少一个线程。

进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。如何处理好同步与互斥是编写多线程程序的难点。多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模

式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题

线程的状态及其相互转换

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。

阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。

等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、 LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。

终止(TERMINATED)：表示该线程已经执行完毕。

创建线程的方式

jdk 1.5 之前两种：

继承Thread 类，并重写父类run方法
实现 Runable 接口，并实现run方法

jdk 1.5 之后新加了两种：
使用Callable和Future创建线程
线程池创建

第一种在实际开发中大都不用，java 不支持多继承

1、继承Thread 类


public class MyThread  extends Thread{
    @Override
    public void run() {
      //  System.out.println("我是 "+this.getName()); 
        System.out.println("我是 "+Thread.currentThread().getName());
    }
}

public static void main(String[] args) {
   		System.out.println(Thread.currentThread().getName()); //main
        Thread m1 = new MyThread();
        Thread m2 = new MyThread();
        m1.run();  //   我是 main    //若run()方法中换成this 则为 我是 Thread-0
        m1.start();  //  我是 Thread-0
        m2.start();   //我是 Thread-1
}

程序一开始执行时，会生成一个线程（这我们称它为main方法）来运行main方法，

Thread.currentThread() 获取当前线程，

运行run( ) 方法时，线程m1 并没有运行，所以获取的还是main线程的nama

start( )方法，开启线程并运行run方法里的内容

当把Thread.currentThread() 换成this 时， m1.run( )运行结果为我是 Thread-0

2、实现 Runnable 接口


public class MyRunable implements Runnable {
    @Override
    public void run() {

            System.out.println("我是："+Thread.currentThread().getName());

    }
}

  		System.out.println(Thread.currentThread().getName()); //main
        MyRunable r1 = new MyRunable();
        MyRunable r2 = new MyRunable();
        Thread thread1 = new Thread(r1);
        Thread thread2 = new Thread(r2);
        thread1.run();  //   我是 main
        thread1.start();  //  我是 Thread-0
        thread2.start();   //我是 Thread-1

3、实现 Callable 接口


public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        
        return "hello word "+Thread.currentThread().getName();
    }
}

// 只会执行 3个语句中的一个
  		FutureTask <String>futureTask = new FutureTask<>(new MyCallable());
        Thread t1 = new Thread(futureTask);
        Thread t2 = new Thread(futureTask);
//        t1.run();    // hello word main
//        t1.start();    // hello word Thread-0
        t2.start();    // hello word Thread-1
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

//  再定义一个FutureTask 可同时运行 m1，m2
 		FutureTask <String>futureTask1 = new FutureTask<>(new MyCallable());
        FutureTask <String>futureTask2 = new FutureTask<>(new MyCallable());
        Thread t1 = new Thread(futureTask1);
        Thread t2 = new Thread(futureTask2);
        t1.start();    // hello word Thread-0
        t2.start();    // hello word Thread-1
        try {
            System.out.println(futureTask1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println(futureTask2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

futureTask 只接收一个 callable 返回结果；当t1 ，t2都start时，写在前面的会被执行

若同时实现了 Runnable 和 Callable 接口，会运行Callable接口，Callable接口本质上也是调用 run( )方法

4、线程池

什么是线程池？

线程池的3个好处
降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

在java 中用Executors 类来表示线程

线程池创建的四种方式：

//创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
public static ExecutorService newFixedThreadPool() 
//创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO        //                                                        LIFO, 优先级)执行。
public static ExecutorService newSingleThreadExecutor()
//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 public static ExecutorService newCachedThreadPool()
 // 创建一个定长线程池，支持定时及周期性任务执行。
 public static ScheduledExecutorService newScheduledThreadPool()

eg：


  ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行！");
                }
            });
        }

//结果
pool-1-thread-1执行！
pool-1-thread-2执行！
pool-1-thread-3执行！
pool-1-thread-4执行！
pool-1-thread-5执行！
pool-1-thread-6执行！
pool-1-thread-9执行！
pool-1-thread-10执行！
pool-1-thread-7执行！
pool-1-thread-8执行！


    ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行！");
                }
            });
        }

//结果
pool-1-thread-1执行！
pool-1-thread-2执行！
pool-1-thread-1执行！
pool-1-thread-2执行！
pool-1-thread-1执行！
pool-1-thread-2执行！
pool-1-thread-1执行！
pool-1-thread-2执行！
pool-1-thread-1执行！
pool-1-thread-2执行！

线程死锁


/**
 * 模拟死锁
 */
public class Main {
    static Object o1 = new Object();
    static Object o2 = new Object();

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o2){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o1){
                        System.out.println(Thread.currentThread().getName()+"执行！");
                    }

                }

            }
        }, "T-1").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (o1){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o2) {
                        System.out.println(Thread.currentThread().getName() + "执行！");
                    }
                }
            }
        }, "T-2").start();



    }
}

线程死锁就是：两个线程相互等待某种资源的一种无限等待下去的一种状态。例如上述代码中，o1 和 o2 是两个Object 对象，用synchronized 进行修饰，T-1线程持有o1的锁，T-2线程持有o2的锁，但两个线程又在执行的时候分别等待获取对方所持有的锁，这样就会无限等待下去。

为什么要给线程 sleep 呢？

这里T-1线程获取到时间片，由于我们在run方法里只执行了打印操作，运行时间很短，在有限的时间片内就拿到两把锁并打印输出，并释放了两把锁，这时当线程T-2拿到时间片，同理执行T-1同样的操作，就不会造成死锁了，为了正确模拟死锁，我们给线程sleep一会儿，就可以等待另一个线程去拿到锁，就能造成死锁。

线程安全

当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需

要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。那么得不到正确的结果，则是线程不安全的。

线程安全问题的原因：

多线程环境
多个线程操作同一共享资源
对该共享资源进行了非原子性操作

如何避免线程安全问题？（根据原因提出解决方案）

多线程环境–将多线程改单线程
多个线程操作同一共享资源–>不共享资源（ThreadLocal、不共享、操作无状态化、不可变）
对该共享资源进行了非原子性操作-- 将非原子性操作改成原子性操作（加锁、使用JDK自带的原子性操作的类、JUC提供的相应的并发工具类）

synchronized 关键字

在了解synchronized之前，先得了解java的锁机制

内置锁
- 每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
互斥锁
- 内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

//修饰普通方法：锁住对象的实例 
public synchronized void method(){}

//修饰静态方法：锁住整个类 
public synchronized static void method(){}

//修饰代码块： 锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容
Object obj = new Object();

synchronized(this){//this被加锁,任何其他要锁this的方法和代码块被阻塞.
 
}

synchronized(obj){//obj被加锁,任何其他要锁obj的代码块被阻塞.

}