java 多线程基础

简介: java 多线程基础

1.继承Runnable接口

package com.vince.xq.kafka.thread;
public class ThreadOne implements Runnable {
    private int i;
    public ThreadOne(int i) {
        this.i=i;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i);
    }
}

使用

package com.vince.xq.kafka;
import com.vince.xq.kafka.thread.ThreadOne;
public class TestThread {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new ThreadOne(i));
            thread.start();
        }
    }
}

结果

2.继承Thread 类

package com.vince.xq.kafka.thread;
public class ThreadTwo extends Thread {
    private int i;
    public ThreadTwo(int i){
        this.i=i;
    }
    @Override
    public void run() {
        System.out.println(i);
    }
}

使用

package com.vince.xq.kafka;
import com.vince.xq.kafka.thread.ThreadTwo;
public class TestThread {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread thread = new ThreadTwo(i);
            thread.start();
        }
    }
}

结果

3.继承callable接口

package com.vince.xq.kafka.thread;
import java.util.concurrent.Callable;
public class ThreadThree implements Callable<String> {
    @Override
    public String call() {
        try {
            int x = 10 / 1;
            return "test";
        } catch (Exception e) {
            e.printStackTrace();
            return "0";
        }
    }
}

使用

package com.vince.xq.kafka;
import com.vince.xq.kafka.thread.ThreadThree;
import java.util.concurrent.*;
public class TestThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
        FutureTask<String> futureTask = new FutureTask<>(new ThreadThree());
        threadPoolExecutor.submit(futureTask);
        System.out.println(futureTask.get());//主线程等子线程结束
        threadPoolExecutor.shutdown();
    }
}

4.主线程等子线程结束实现方法

(1)Future.get()

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
        FutureTask<String> futureTask = new FutureTask<>(new ThreadThree());
        threadPoolExecutor.submit(futureTask);
        System.out.println(futureTask.get());//主线程等子线程结束
        threadPoolExecutor.shutdown();

(2)CountDownLatch

package com.vince.xq.kafka;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(2);
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        executorService.execute(()-> {
            try {
                test1(countDownLatch);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.execute(()-> {
            try {
                test2(countDownLatch);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
        countDownLatch.await();
        System.out.println("0000");
        System.out.println("costTime:");
        System.out.println(System.currentTimeMillis() - startTime);
    }
    public static void test1(CountDownLatch countDownLatch) throws InterruptedException {
        Thread.sleep(2000);
        System.out.println(111);
        countDownLatch.countDown();
        //return "111";
    }
    public static void test2(CountDownLatch countDownLatch) throws InterruptedException {
        Thread.sleep(2000);
        System.out.println(222);
        countDownLatch.countDown();
    }
    public static String test3() throws InterruptedException {
        Thread.sleep(2000);
        return "333";
    }
}
class MyUncaughtExceptionHandle implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("caught " + e);
    }
}
class HandleThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        System.out.println("create thread t");
        Thread t = new Thread(r);
        System.out.println("set uncaughtException for t");
        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandle());
        return t;
    }
}

(3)Thread.join()

long startTime = System.currentTimeMillis();
Thread thread = new Thread(new ThreadOne("1"));
thread.start();
//thread.join();
long costTime = System.currentTimeMillis() - startTime;
System.out.println("costTime:" + costTime);
package com.vince.xq.kafka.thread;
import java.util.concurrent.atomic.AtomicBoolean;
public class ThreadOne implements Runnable {
    private static AtomicBoolean exists = new AtomicBoolean(false);
    private String name;
    public ThreadOne(String i) {
        this.name = i;
    }
    @Override
    public void run() {
        if (exists.compareAndSet(false, true)) {
            System.out.println(name + "start");
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            exists.set(false);
            System.out.println("111111");
        } else {
            System.out.println(name + " give up");
        }
    }
}

没有thread.join

有thread.join

5.java 守护线程

java并发编程学习: 守护线程(Daemon Thread)

一个线程去执行数据,一个线程设置为守护线程去打印日志


目录
打赏
0
0
0
0
8
分享
相关文章
Java多线程基础
本文主要讲解多线程相关知识,分为两部分。第一部分涵盖多线程概念(并发与并行、进程与线程)、Java程序运行原理(JVM启动多线程特性)、实现多线程的两种方式(继承Thread类与实现Runnable接口)及其区别。第二部分涉及线程同步(同步锁的应用场景与代码示例)及线程间通信(wait()与notify()方法的使用)。通过多个Demo代码实例,深入浅出地解析多线程的核心知识点,帮助读者掌握其实现与应用技巧。
|
4月前
|
【Java并发】【线程池】带你从0-1入门线程池
欢迎来到我的技术博客!我是一名热爱编程的开发者,梦想是编写高端CRUD应用。2025年我正在沉淀中,博客更新速度加快,期待与你一起成长。 线程池是一种复用线程资源的机制,通过预先创建一定数量的线程并管理其生命周期,避免频繁创建/销毁线程带来的性能开销。它解决了线程创建成本高、资源耗尽风险、响应速度慢和任务执行缺乏管理等问题。
254 60
【Java并发】【线程池】带你从0-1入门线程池
|
2月前
|
【源码】【Java并发】从InheritableThreadLocal和TTL源码的角度来看父子线程传递
本文涉及InheritableThreadLocal和TTL,从源码的角度,分别分析它们是怎么实现父子线程传递的。建议先了解ThreadLocal。
85 4
【源码】【Java并发】从InheritableThreadLocal和TTL源码的角度来看父子线程传递
|
28天前
|
java 多线程异常处理
本文介绍了Java中ThreadGroup的异常处理机制,重点讲解UncaughtExceptionHandler的使用。通过示例代码展示了当线程的run()方法抛出未捕获异常时,JVM如何依次查找并调用线程的异常处理器、线程组的uncaughtException方法或默认异常处理器。文章还提供了具体代码和输出结果,帮助理解不同处理器的优先级与执行逻辑。
【高薪程序员必看】万字长文拆解Java并发编程!(9-2):并发工具-线程池
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池,废话不多说让我们直接开始。
46 0
Java网络编程,多线程,IO流综合小项目一一ChatBoxes
**项目介绍**:本项目实现了一个基于TCP协议的C/S架构控制台聊天室,支持局域网内多客户端同时聊天。用户需注册并登录,用户名唯一,密码格式为字母开头加纯数字。登录后可实时聊天,服务端负责验证用户信息并转发消息。 **项目亮点**: - **C/S架构**:客户端与服务端通过TCP连接通信。 - **多线程**:采用多线程处理多个客户端的并发请求,确保实时交互。 - **IO流**:使用BufferedReader和BufferedWriter进行数据传输,确保高效稳定的通信。 - **线程安全**:通过同步代码块和锁机制保证共享数据的安全性。
130 23
|
3月前
|
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
当我们创建一个`ThreadPoolExecutor`的时候,你是否会好奇🤔,它到底发生了什么?比如:我传的拒绝策略、线程工厂是啥时候被使用的? 核心线程数是个啥?最大线程数和它又有什么关系?线程池,它是怎么调度,我们传入的线程?...不要着急,小手手点上关注、点赞、收藏。主播马上从源码的角度带你们探索神秘线程池的世界...
204 0
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
Java社招面试题:一个线程运行时发生异常会怎样?
大家好,我是小米。今天分享一个经典的 Java 面试题:线程运行时发生异常,程序会怎样处理?此问题考察 Java 线程和异常处理机制的理解。线程发生异常,默认会导致线程终止,但可以通过 try-catch 捕获并处理,避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理,不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制,为面试做好准备。如果你觉得有帮助,欢迎收藏、转发!
234 14
Java 面试必问!线程构造方法和静态块的执行线程到底是谁?
大家好,我是小米。今天聊聊Java多线程面试题:线程类的构造方法和静态块是由哪个线程调用的?构造方法由创建线程实例的主线程调用,静态块在类加载时由主线程调用。理解这些细节有助于掌握Java多线程机制。下期再见! 简介: 本文通过一个常见的Java多线程面试题,详细讲解了线程类的构造方法和静态块是由哪个线程调用的。构造方法由创建线程实例的主线程调用,静态块在类加载时由主线程调用。理解这些细节对掌握Java多线程编程至关重要。
96 13
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等