java并发基础(一)

最新推荐文章于 2024-05-27 09:49:55 发布
最新推荐文章于 2024-05-27 09:49:55 发布
阅读量157 收藏 1
点赞数
分类专栏： java 计算机基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37993487/article/details/83663014
版权

java并发基础(一)

本文主要讲述线程的创建及相关知识,参考《thinking in java》一书第21章，记录本人在学习过程中的笔记

定义任务

  1. 线程可以驱动任务，因此需要一种描述任务的方式，这可以由Runnable接口来提供,并且实现run方法，例如

    public class RunnableItem implements Runnable{    
    
	protected int countDown = 10;

    private static int taskCount = 0;

    private int taskId = taskCount++;

    public RunnableItem() {
    }

    public RunnableItem(int countDown) {
        this.countDown = countDown;
    }

    @Override
    public String toString() {
        return "#" + taskId + "(" + countDown + ")";
    }

    @Override
    public void run() {
        while (countDown-- > 0){
            System.out.println(this);
            Thread.yield();
        }
    }
}

  2. Thread.yield():表明将CPU时间让给该进程的其它线程来执行，该选择完全是自愿的，但这只是一个暗示，并没有机制保证它会被采纳。

执行任务

  1. 传统方式，将一个任务提交给一个Thread构造器

    public static void main(String[] args) {
    for (int i = 0; i < 5; i++) new Thread(new RunnableItem()).start();
    System.out.println("the end?");
}

  2. 分析结果：具体的运行结果不再说明，需要注意的是在程序一开始就打印了“the end?”，这是因为RunnableItem.run是由不同的线程执行的，此时你仍可以执行main()线程中的其它操作

  3. 使用Executor(java.util.concurrent)管理Thread对象：

    public static void main(String[] args) {
	ExecutorService service = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) 
		service.execute(new RunnableItem());
    System.out.println("the end?");
	service.shutdown();
}

  4. shutdown()方法：防止新任务提交给这个Executor，当前线程将继续运行调用shutdown()之前提交的所有任务，该程序将在所有任务完成之后尽快退出

  5. 各种ExecutorService

    名称描述
    newCachedThreadPool在程序执行过程中会创建与所需线程数量相同的线程，然后在它回收旧线程时停止创建新线程
    newFixThreadPool一次性预先执行代价高昂的线程分配，也可以限制线程的数量
    SingleThreadExecutor相当于线程数量为1的newFixThreadPool

  6. 还可以直接继承Thread，调用start()方法即可运行任务

    public class ThreadTest extends Thread{
    
    private static int count = 10;

    private final int id = count--;

    @Override
    public void run() {
        System.out.println(this);
    }

    @Override
    public String toString() {
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++)
            new ThreadTest().start();
    }
}

从任务中产生返回值

  1. Runnable是执行工作的独立任务，但是不返回任何值，需要返回值的话可以实现Callable接口

    public class CallableTask implements Callable<String> {

    private int taskId;

    public CallableTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public String call() throws Exception {
        return Integer.toString(taskId);
    }
}

  2. 测试Callable任务：

    public static void main(String[] args) {

    ExecutorService service = Executors.newCachedThreadPool();
    ArrayList<Future<String>> results = new ArrayList<>();
    for (int i = 0; i < 10; i++) results.add(service.submit(new CallableTask(i)));

    for (Future<String> fs : results) {
        try {
            System.out.println(fs.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    service.shutdown();
}

  3. submit()方法会产生Future对象，它用Callable返回结果的特定类型进行了参数化，可以用isDone()方法来查询Futrue是否完成。当任务完成时，可以用get()方法获取结果。如果不采用isDone()方法直接使用get()，那么在任务没有结束前，一直会阻塞着。

线程休眠

  1. Thread.sleep()和TimeUnit的sleep都可以进行线程的睡眠，其中TimeUnit是一个枚举量，可以选择不同的单位，例如TimeUnit.SECONDS.sleep(1)，表示睡眠一秒。
  2. 对sleep调用可以抛出InterruptedException异常，在run()方法中捕获，因为异常不可以跨线程传播到其它线程(例如main())，所以你必须本地处理任务内部产生的异常。

线程的优先级

  1. 调度器倾向于让优先级高的线程先执行，并不是说优先级低的线程得不到执行，只是执行的频率比较低。
  2. 调用Thread.currentThread的getPriority()和setPriority()可以修改当前线程的优先级。

后台线程

  1. 后台线程(daemon)指的是程序运行的时候后台提供一种通用服务的线程，但种线程并不属于程序中不可或缺的一部分。所以所有的非后台线程结束的时候，程序也会结束，同时会杀死所有的后台线程。反过来说，只要有任何的非后台线程还在运行，那么程序就不会终止

  2. 线程在启动之前调用setDaemon()方法即可设置为后台线程

  3. 通过编写定制ThreadFactory可以定制由Executor创建的线程的属性(后台、优先级、名称)

    public class DaemonThreadFactory implements ThreadFactory {
	    @Override
	    public Thread newThread(Runnable r) {
	        Thread thread = new Thread(r);
	        thread.setDaemon(true); // 设置为后台线程
	        return thread;
	    }
	}

  4. 测试后台线程

    public class DaemonFromFactory implements Runnable {
    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(Thread.currentThread() + " " + this);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool(new DaemonThreadFactory());

        for (int i = 0; i < 10; i++) service.execute(new DaemonFromFactory());

        System.out.println("all daemons started");
        TimeUnit.MILLISECONDS.sleep(500);
    }
}

  5. 一个由后台线程创建的所有线程都将会自动设置为后台线程。

  6. 后台线程不会运行finally语句，例如一个将会被设置为后台运行的任务的run()方法如下，实践证明不会执行

    @Override
public void run() {
    System.out.println("starting ADaemon");
    try {
        TimeUnit.MILLISECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("run run ??");
    }
}

  7. 当最后一个非后台线程终止时，后台线程会突然终止。一旦main()退出，JVM就会关闭所有的后台线程

加入一个线程

  1. 先看下面代码

    class Sleeper extends Thread{

    private int duration;

    public Sleeper(String name, int duration){
        super(name);
        this.duration = duration;
        start();
    }

    @Override
    public void run() {
        try {
            sleep(duration);
        } catch (InterruptedException e) {
            System.out.println(getName() + " is interrupted ? " + isInterrupted());
        }
        System.out.println(getName() + " has awakened");
    }
}

class Joiner extends Thread {

    private Sleeper sleeper;

    public Joiner(String name, Sleeper sleeper){
        super(name);
        this.sleeper = sleeper;
        start();
    }

    @Override
    public void run() {
        try {
            sleeper.join(); // 需要等待sleeper执行完才可以继续执行
        } catch (InterruptedException e) {
            System.out.println("interrupted");
        }
        System.out.println(getName() + " join completed");
    }
}

public class Joining{
    public static void main(String[] args) {
        Sleeper sleepy = new Sleeper("sleepy", 1500);
        Sleeper grumpy = new Sleeper("grumpy", 1500);
        Joiner dopey = new Joiner("dopey", sleepy);
        Joiner doc = new Joiner("doc", grumpy);
        grumpy.interrupt();
    }
}

  2. 一个线程可以在其它线程上调用join()方法，作用是这个线程会被挂起，直到指定的其它线程执行完毕才会继续执行。如果在调用join()时加上一个超时参数，即使目标线程在这段时间到期时还没有结束，join()方法总可以返回

  3. 一个线程在该线程上调用interrupt()时，将给该线程一个标志，表明该线程已经被中断，但是异常被捕获时将会清理这个标志(运行上面的代码即可观察到)。

捕捉异常

  1. 运行如下代码，你会发现main中不可以捕获子线程逃逸的异常

    public class ExceptionThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("test");
    }

    public static void main(String[] args) {
        try {
            ExecutorService executorService = Executors.newCachedThreadPool();
            executorService.execute(new ExceptionThread());
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            System.out.println("exception has been handled");
        }
    }
}

  2. 要解决上述问题，需要在创建线程池时，传递一个生成线程的工厂，该工厂实现ThreadFactory类，重写newThread方法，此方法内还需要为新生成的线程附着一个自定义的异常处理器，该处理器需要实现Thread.UncaughtExceptionHandler类

    class ExceptionThread2 implements Runnable {
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        throw new RuntimeException("test"); // 抛出运行时异常，查看是否能够捕获
    }
}

class MyUncaughtExceptionFactory implements Thread.UncaughtExceptionHandler {

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("caught " +  e);
    }
}

class HandlerThreadFactory implements ThreadFactory{

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setUncaughtExceptionHandler(new MyUncaughtExceptionFactory());
        return thread;
    }
}

public class CaptureUncaughtException {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool(new HandlerThreadFactory());
        service.execute(new ExceptionThread2());
        service.shutdown();
    }
}
dadagum
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java并发基础
11-20
Java并发基础
java并发总结
liujiqing123的博客
10-11 1万+
一、并发基础 ㅤ 1、进程与线程 ㅤ 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 一个进程之内可以分为一到多个
Java 并发编程
m0_61470267的博客
06-05 9158
java线程的回顾，java多线程出现的问题及解决方案，引入线程池的的原因，线程池的参数设置，以及引入ThreadLocal 线程变量，理解ThreadLocal的底层实现原理。
Java基础-并发篇
稷下
05-12 4308
3.1. JAVA 并发知识库 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x8MLzghL-1652349583715)(…/images/31.png)] 3.2. JAVA 线程实现/创建方式 3.2.1. 继承 Thread 类 ​ Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方 法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线 程，并执行
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
全面详解Java并发编程：从基础到高级应用
最新发布
微笑听雨
05-27 7785
Java并发编程提供了强大的工具和框架，帮助开发者有效管理多线程任务，提升应用程序性能。理解并掌握基本概念、线程管理、同步机制和高级并发工具，并遵循最佳实践，可以编写出高效、安全、可靠的并发程序。
Java并发编程详解：实现高效并发应用的关键技术
唯有努力，方可自信！
06-22 1万+
本文介绍了Java并发编程的关键技术，包括线程安全性、锁机制、并发集合、原子操作和并发工具。通过使用synchronized关键字和ReentrantLock锁来实现线程安全性，使用ConcurrentHashMap和CopyOnWriteArrayList等并发集合来实现安全数据访问，以及使用AtomicBoolean和AtomicInteger等原子类来实现线程安全的原子操作。此外，还介绍了CountDownLatch和CyclicBarrier等并发工具，用于线程间的同步操作。通过学习和运用这些技术，
【Java并发面试】10道不得不会的Java并发基础面试题
JavaPub
12-26 3813
1. start()方法和run()方法的区别 2. volatile关键字的作用 3. sleep方法和wait方法有什么区别 4. 如何停止一个正在运行的线程？ 5. java如何实现多线程之间的通讯和协作？(如何在两个线程间共享数据？) 6. 什么是ThreadLocal? 7. Java中CyclicBarrier 和 CountDownLatch有什么不同？ 8. 如何避免死锁？ 9. Java中synchronized 和 ReentrantLock 有什么不同？ 10. 有三个线程T1，T2，
深入理解 Java 并发锁
m0_50414588的博客
04-02 4495
一、并发锁简介 确保线程安全最常见的做法是利用锁机制（Lock、sychronized）来对共享数据做互斥同步，这样在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，那么操作必然是原子性的，线程安全的。 在工作、面试中，经常会听到各种五花八门的锁，听的人云里雾里。锁的概念术语很多，它们是针对不同的问题所提出的，通过简单的梳理，也不难理解。 可重入锁 可重入锁又名递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。 可重入锁可以在一定程度上避免死锁。 Reentrant.
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
java并发基础学习笔记
02-26
想对并发有一定了解的人群
Java并发编程基础.pdf
04-19
Java并发编程基础主要包括以下几个核心方面： 线程与线程状态：理解Java中线程的基本概念，包括线程的创建、启动、暂停、恢复和终止。熟悉线程的生命周期及其不同状态，如新建、就绪、运行、阻塞和死亡。 线程同步...
java并发编程与实践
02-20
"Java并发编程与实践"文档深入剖析了这一主题，旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元（如CPU）中同时执行两个或更多任务的能力。在Java中，这主要通过线程来实现，...
XML和XSD
qq_37993487的博客
05-10 1万+
初识XML和XSD 最近在学习Spring,由于要写大量的xml配置文件,而且配置文件中也用到了xsd的相关知识,于是整理一些本人不熟悉的知识点.建议先学习html的相关知识.本文部分内容参考w3school. XML 类似HTML树结构,具有自我描述性语法,语法也类似html,不作多说. xml命名空间:如果两个不同的文档使用相同的元素名时,就会发生命名冲突. fil...
网络基础知识-网络传输协议
qq_37993487的博客
04-14 1586
网络基础知识-常见的网络传输协议 本博客参考了维基百科,整理一下作为我的复习纲要. 地址解析协议(ARP) 介绍:解析网路层地址来找寻数据链路层地址的一个在网络协议包中极其重要的网络传输协议. 功能:同一局域网中的一台主机要和另一台主机进行直接通信，必须要知道目标主机的MAC地址。而在TCP/IP协议中，网络层和传输层只关心目标主机的IP地址。这就导致在以太网中使用IP协议时，...
c++指针和自由储存空间
qq_37993487的博客
07-30 1233
c++指针和储存空间 本博文为本人阅读c++ primer plus第4章复合类型后做的小笔记，仅记录本人不熟悉或者容易犯错的地方 概述 指针是一个变量，储存的是值得地址，而不是值本身 地址运算符&amp;amp;，可以获得变量的所在地址 指针名表示的是地址，*运算符被称为间接值(indirect value)或者解除引用(dereferencing)；简单来说，使用*可以获得指针指向...
java泛型之自限定类型和参数协变
qq_37993487的博客
11-13 1115
java泛型之自限定类型和参数协变 本博文参考《thinking in java》第四版第15张“泛型”中的相关内容和网络上的各种博客，本文也是几个月前的一篇博文“java泛型(一)”的后续，主要是书本的代码加上自己的理解和感悟 背景 为何突然想起看这部分内容，这是由于最近有一个小项目，有几个对象的构造十分复杂，一大堆的setter和getter或者冗长的构造函数太辣眼睛。本着做一次小项目学...
java 并发编程基础
09-17
Java并发编程是指在Java程序中使用多线程实现并发执行的编程技术。它能有效利用多核处理器的优势，提升程序的性能和响应能力。以下是Java并发编程的基础知识： 1. 线程与进程：Java中的线程是程序中执行的最小单位，线程共享进程的资源，包括内存空间和文件等。多线程可以同时执行不同的任务，相比单线程能更高效地利用系统资源。 2. 线程创建：Java中创建线程有两种方式，一种是继承Thread类，实现run()方法；另一种是实现Runnable接口，重写run()方法。通过调用start()方法启动线程。 3. 线程同步：多个线程在访问共享资源时可能会产生竞争条件，可能会导致数据不一致或者出现死锁等问题。通过使用同步机制来保证线程安全，例如使用synchronized关键字实现对共享资源的互斥访问。 4. 线程通信：线程之间可以通过共享变量来进行通信。使用wait()、notify()和notifyAll()方法实现线程的等待和唤醒。 5. 线程池：线程池是一种管理线程的机制，可以有效控制线程的数量和复用线程资源，避免频繁创建销毁线程的开销。 6. 并发容器：Java提供了一些线程安全的数据结构，如ConcurrentHashMap和ConcurrentLinkedQueue等，用于在多线程环境下安全地操作数据。 7. 原子操作：Java提供了一些原子操作类，如AtomicInteger和AtomicLong等，它们能够保证对共享数据的操作是原子的，不会发生数据不一致的情况。 8. 同步工具类：Java提供了一些同步工具类，如CountDownLatch和CyclicBarrier等，用于控制线程的执行顺序和线程之间的同步。 以上是Java并发编程的基础知识，掌握了这些知识可以更好地利用多线程来提高程序的性能和并发能力。同时也需要注意并发编程可能带来的线程安全问题，合理使用同步机制和并发容器等工具类来保证程序的正确运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值