JAVA线程-CSDN博客

本文链接：https://blog.csdn.net/ENDLESSone/article/details/77849019

相关细节

1. 进程和线程的区别

一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。

2. 多线程编程的好处是什么？

在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。

3. 用户线程和守护线程有什么区别？

当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。

4. 我们如何创建一个线程？

有三种创建线程的方法：一是实现Runnable接口或者Callable接口，然后将它传递给Thread的构造函数，创建一个Thread对象,区别是Callable有返回值且可抛出异常；三是直接继承Thread类。

5. 有哪些不同的线程生命周期？

当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。

6. 可以直接调用Thread类的run()方法么？

当然可以，但是如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，是在当前线程执行，为了在新的线程中执行我们的代码，必须使用Thread.start()方法。

7. 如何让正在运行的线程暂停一段时间？

我们可以使用Thread类的Sleep()方法让线程暂停一段时间。需要注意的是，这并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，并且根据线程调度，它将得到执行。

8. 你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。

9. 什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)？

线程调度器是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择（也就是说不要让你的程序依赖于线程的优先级）。

10. 在多线程中，什么是上下文切换(context-switching)？

上下文切换是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。

11. 你如何确保main()方法所在的线程是Java程序最后结束的线程？

我们可以使用Thread类的join()方法来确保所有程序创建的线程在main()方法退出前结束。

12.线程之间是如何通信的？

当线程间是可以共享资源时，线程间通信是协调它们的重要的手段。Object类中wait()、notify()、notifyAll()方法可以用于线程间通信关于资源的锁的状态。

13.为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object类里？

Java的每个对象中都有一个锁(monitor，也可以成为监视器) 并且wait()，notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分，这样Java的每一个类都有用于线程间通信的基本方法

14. 为什么wait(), notify()和notifyAll()必须在同步方法或者同步块中被调用？

当一个线程需要调用对象的wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的notify()方法。同样的，当一个线程需要调用对象的notify()方法时，它会释放这个对象的锁，以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用。

15. 为什么Thread类的sleep()和yield()方法是静态的？

Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作，并避免程序员错误的认为可以在其他非运行线程调用这些方法。

16.如何确保线程安全？

在Java中可以有很多方法来保证线程安全——同步，使用原子类(atomic concurrent classes)，实现并发锁，使用volatile关键字，使用不变类和线程安全类。

17. volatile关键字在Java中有什么作用？

当我们使用volatile关键字去修饰变量的时候，所以线程都会直接读取该变量并且不缓存它。这就确保了线程读取到的变量是同内存中是一致的。

18. 同步方法和同步块，哪个是更好的选择？

同步块是更好的选择，因为它不会锁住整个对象（当然你也可以让它锁住整个对象）。同步方法会锁住整个对象，哪怕这个类中有多个不相关联的同步块，这通常会导致他们停止执行并需要等待获得这个对象上的锁。

19.如何创建守护线程？

使用Thread类的setDaemon(true)方法可以将线程设置为守护线程，需要注意的是，需要在调用start()方法前调用这个方法，否则会抛出IllegalThreadStateException异常。

20. 什么是ThreadLocal?

ThreadLocal用于创建线程的本地变量，我们知道一个对象的所有线程会共享它的全局变量，所以这些变量不是线程安全的，我们可以使用同步技术。但是当我们不想使用同步的时候，我们可以选择ThreadLocal变量。
每个线程都会拥有他们自己的Thread变量，它们可以使用get()\set()方法去获取他们的默认值或者在线程内部改变他们的值。ThreadLocal实例通常是希望它们同线程状态关联起来是private static属性。

21. 什么是Thread Group？为什么建议使用它？

ThreadGroup是一个类，它的目的是提供关于线程组的信息。
ThreadGroup API比较薄弱，它并没有比Thread提供了更多的功能。它有两个主要的功能：一是获取线程组中处于活跃状态线程的列表；二是设置为线程设置未捕获异常处理器(ncaught exception handler)。但在Java 1.5中Thread类也添加了setUncaughtExceptionHandler(UncaughtExceptionHandler eh) 方法，所以ThreadGroup是已经过时的，不建议继续使用。

22. 什么是Java线程转储(Thread Dump)，如何得到它？

线程转储是一个JVM活动线程的列表，它对于分析系统瓶颈和死锁非常有用。有很多方法可以获取线程转储——使用Profiler，Kill -3命令，jstack工具等等。我更喜欢jstack工具，因为它容易使用并且是JDK自带的。由于它是一个基于终端的工具，所以我们可以编写一些脚本去定时的产生线程转储以待分析。读这篇文档可以了解更多关于产生线程转储的知识。

23. 什么是死锁(Deadlock)？如何分析和避免死锁？

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。
分析死锁，我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id，用这个id我们可以找出哪些线程已经拥有了它的对象锁。
避免嵌套锁，只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法。

24. 什么是Java Timer类？如何创建一个有特定时间间隔的任务？

java.util.Timer是一个工具类，可以用于安排一个线程在未来的某个特定时间执行。Timer类可以用安排一次性任务或者周期任务。
java.util.TimerTask是一个实现了Runnable接口的抽象类，我们需要去继承这个类来创建我们自己的定时任务并使用Timer去安排它的执行。

25. 什么是线程池？如何创建一个Java线程池？

一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行的任务的队列。
java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。

26.为何要使用同步？

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，
从而保证了该变量的唯一性和准确性。

27.线程同步的方法

synchronized关键字修饰
使用volatile修饰临界变量实现线程同步
使用重入锁实现线程同步

创建一个ReentrantLock实例
lock() 获得锁
unlock() 释放锁
ThreadLocal管理变量

ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的”初始值”
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
使用阻塞队列实现线程同步

LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
对变量进行原子操作实现线程同步

原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即这几种行为要么同时完成，要么都不完成。
util.concurrent.atomic包中提供了创建了原子类型变量的工具类
AtomicInteger xx = new AtomicInteger(20); // : 创建具有给定初始值的新的AtomicInteger
xx.addAndGet(1); // : 以原子方式将给定值与当前值相加
xx.get(); // : 获取当前值

创建并启动一个线程

启动一个线程的九种方式

实现Runnable接口的匿名内部类实现的线程

        Runnable x = () -> System.out.println("This is Thread");
        new Thread(x).start();                                        \\一   

        EventQueue.invokeLater(x);    //加入分发队列同步启动             \\二

        EventQueue.invokeAndWait(x);                                   \\三  

        SwingUtilities.invokeLater(x);                                 \\四

        SwingUtilities.invokeAndWait(x);                               \\五

        Executors.newFixedThreadPool(100).execute(x);                  \\六

        Executors.newFixedThreadPool(100).submit(x);                   \\七
        new ThreadPoolExecutor(200, 1000, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(1000)).execute(x);    \\八

        new ThreadPoolExecutor(200, 100, 200, TimeUnit.MILLISECONDS,  
                new ArrayBlockingQueue<Runnable>(100)).submit(x);      \\九

继承Thread类的匿名函数实现的线程

        new Thread(() -> System.out.println("This is new Thread")).start();

实现的Callable接口的匿名内部类实现的线程,带返回值可抛出异常的线程

Callable<Integer> xx = () -> {//隐式抛出异常 InterruptedException
            Thread.sleep(10);
            return 666;
        };
        FutureTask<Integer> xv = new FutureTask<>(xx);//包装为Runnable
        new Thread(xv).start();
        try {//异常被抛到FutureTask,不调用其实例的方法则不用处理异常
            System.out.println(xv.get());
        } catch (Exception e) {
        }

FutureTask<String> task = new FutureTask<String>(() -> {
            System.out.println("233");
            return "sss";
        });
        new Thread(task).start();
        System.out.println(task.get());//sss

线程池

import java.awt.EventQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
public class Threadpools {

    static int i = 1;

    static int i() {
        return i++;
    }

    public static void main(String[] args) {

        EventQueue.invokeLater(() -> {
            System.out.println("This is a new Thread of EventQueue !");
        });

        ThreadPoolExecutor ex = new ThreadPoolExecutor(200, 1000, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(1000));
        ex.execute(() -> {
            System.out.println("This is a new Thread of ThreadPoolExecutor!");
        });

        ExecutorService pool = Executors.newFixedThreadPool(1000);
        pool.execute(() -> {
            System.out.println("This is a new Thread of ExecutorService");
        });
        Runnable xx = () -> {// 创建Runnable对象
            System.out.println("正在执行:" + Thread.currentThread().getName());
            System.out.println("This is a new Thread! 线程名称:" + Threadpools.i());
        };
        Stream.generate(() -> new Thread(xx)).limit(100).forEach((x) -> {
            // 创建一个流,参数为匿名工厂函数,其返回值为线程对象,个数由limit参数控制,遍历
            // x.run();
            // 在当前线程执行实现了线程接口的类的对象的run()方法,而不启动新的线程,相当于普通的方法调用;forEach需等待此线程结束以执行下一次遍历
            // x.start();
            // 此时启动一个新的线程Thread-<序号>;线程执行完自动结束;forEach并不等待此线程结束以执行下一次遍历
            // EventQueue.invokeAndWait(x);
            // 此时启动一个线程AWT-EventQueue-0;线程执行完自动结束;forEach需等待此线程结束以执行下一次遍历
            // SwingUtilities.invokeAndWait(x);
            // 此时启动一个线程AWT-EventQueue-0;线程执行完自动结束;forEach需等待此线程结束以执行下一次遍历
            // EventQueue.invokeLater(x);
            // 此时启动一个线程AWT-EventQueue-0;线程执行完自动结束;forEach需等待此线程结束以执行下一次遍历
            // SwingUtilities.invokeLater(x);
            // 此时启动一个线程AWT-EventQueue-0;线程执行完自动结束;forEach需等待此线程结束以执行下一次遍历
            // ex.submit(x);
            // 线程加入线程池,由ex调度;线程执行完不自动结束;forEach并不等待此线程结束以执行下一次遍历
            // ex.execute(x);
            // 线程加入线程池,由ex调度;线程执行完不自动结束;forEach并不等待此线程结束以执行下一次遍历
            // pool.submit(x);
            // 线程加入线程池,由pool调度;线程执行完不自动结束;forEach并不等待此线程结束以执行下一次遍历
            // pool.execute(x);
            // 线程加入线程池,由pool调度;线程执行完不自动结束;forEach并不等待此线程结束以执行下一次遍历
        });
        pool.shutdown();
        // 待池中线程执行完关闭线程
        ex.shutdown();
        // 待池中线程执行完关闭线程
    }
}

线程组

 import java.util.Arrays;
/**
*@2017年9月9日@下午1:30:55
*@Endless
* 线程分组 
*/
public class 线程组 {
    public static void main(String[] args) {
        Runnable x = () -> {
            String name = Thread.currentThread().getName();
            String names = Thread.currentThread().getThreadGroup().getName();
            System.out.println("This is a new Thread! 线程名称:" + name + " 所属组:" + names);
        };
        ThreadGroup xx = new ThreadGroup("第一组");
        Thread[] zz = new Thread[] { new Thread(xx, x), new Thread(xx, x), new Thread(xx, x), new Thread(xx, x),
                new Thread(xx, x) };
        Arrays.asList(zz).forEach((xxx) -> {
            xxx.start();
        });
        xx.interrupt();// 停止组内所有线程
        xx.activeCount();// 当前线程组中活动线程的数量
        xx.setDaemon(false);// 设置为后台线程组
        xx.isDaemon(); // 是否为后台线程组
        xx.setMaxPriority(10);// 设置线程组的最高优先级
    }
}

import java.awt.Font;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.stream.Stream;
import javax.swing.JFrame;
import javax.swing.JLabel;
/**
*@2017年9月4日@上午8:30:55
*@Endless
*线程实现的时钟,无限个线程，每个线程刷新一次Label为当前时间 
*/
public class 时钟 {
    public static void main(String[] args)  throws InterruptedException{
        JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("时钟");   
        frame.setAlwaysOnTop(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);   
        frame.setSize(500, 200); 
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        JLabel l = new JLabel(); 
        l.setFont(new Font("Serif",Font.BOLD,35));
        frame.add(l);   
        Stream.generate(()->new Thread(()->{
            l.setText((new SimpleDateFormat("   yyyy年M月d日  hh:mm:ss:SSS").format(new Date().getTime())));
            try {Thread.sleep(19);} catch (Exception x) {}})).forEachOrdered(n->{//无限循环
            System.out.println(n.getName()+" "+n.getId()+" "+l.getText());
            n.run();
            });
    }   
}

线程同步

class shop {
    void buy() {
        Thread x = Thread.currentThread();
        System.out.println(x.getId() + "进入商店...");
        System.out.println(x.getId() + "挑衣服...");
        try {
            synchronized (this) {     //同步快儿同时只能由一个线程访问
                System.out.println(x.getId() + "正在试衣服...");
                Thread.sleep(300);
                System.out.println(x.getId() + "试完衣服...");
                Thread.sleep(300);
            }
            System.out.println(x.getId() + "逛来逛去...");
            Thread.sleep(300);
            System.out.println(x.getId() + "结账离开...");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class sync同步 {
    public static void main(String[] args) {
        shop shop = new shop();

        new Thread(() -> shop.buy()).start();
        new Thread(() -> shop.buy()).start();

    }
}

import java.io.File;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
/**
*(转发)
*多线程复制文件
*/


class CopyThread extends Thread {

    private String srcPath;// 原文件地址

    private String destPath;// 目标文件地址

    private int start, end;// start指定起始位置，end指定结束位置

    // 构造CopyThread方法

    public CopyThread(String srcPath, String destPath, int start, int end) {

        this.srcPath = srcPath;// 要复制的源文件路径

        this.destPath = destPath;// 复制到的文件路径

        this.start = start;// 复制起始位置

        this.end = end;// 复制结束位置

    }

    // 重写run()方法

    @Override
    public void run() {

        try {

            // 创建一个只读的随机访问文件

            RandomAccessFile in = new RandomAccessFile(srcPath, "r");

            // 创建一个可读可写的随机访问文件

            RandomAccessFile out = new RandomAccessFile(destPath, "rw");

            in.seek(start);// 将输入跳转到指定位置

            out.seek(start);// 从指定位置开始写

            FileChannel inChannel = in.getChannel(); // 文件输入通道

            FileChannel outChannel = out.getChannel();// 文件输出通道

            // 锁住需要操作的区域,false代表锁住

            FileLock lock = outChannel.lock(start, (end - start), false);

            // 将字节从此通道的文件传输到给定的可写入字节的outChannel通道。

            inChannel.transferTo(start, (end - start), outChannel);

            lock.release();// 释放锁

            out.close();// 从里到外关闭文件

            in.close();// 关闭文件
            System.out.println("Done!");
        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

public class 多线程复制文件 {

    public static void main(String[] args) {

        // 要复制的源文件路径

        String srcPath = "E:\\RmDownloads\\LenovoDM_Setup.zip";

        String destPath = "F:\\xxx.zip";

        // 获得源文件长度

        File f = new File(srcPath);

        long len = f.length();

        int count = 3;// 需要的线程数

        int oneNum = (int) (len / count);// 每个线程负责的文件长度，强制转换成int类型

        // 用for循环处理划分文件的第一部分跟第二部分(循环次数可根据定义的线程数调整)

        for (int i = 0; i < count - 1; i++) {

            // oneNum * i 起始位置， oneNum * (i + 1)要复制数据的长度

            CopyThread ct = new CopyThread(srcPath, destPath, oneNum * i, oneNum * (i + 1));

            ct.start();

        }
        // 文件长度不能整除的部分放到最后一段处理
        CopyThread ct = new CopyThread(srcPath, destPath, oneNum * (count - 1), (int) len);
        ct.start();
    }
}