JAVA线程

最新推荐文章于 2025-04-15 04:00:00 发布
最新推荐文章于 2025-04-15 04:00:00 发布
阅读量219 收藏
点赞数
分类专栏： java学习 文章标签： java线程基础

JAVA线程

- 1.实现

一种是继承Thread类；
实现Runnable接口；
实现Callable接口，该接口中的call方法可以在线程执行结束时产生一个返回值:

public class ThreadFuture {

    public static void main(String[] args) throws Exception {

        ExecutorService service = Executors.newFixedThreadPool(1);
        Future<Integer> result = service.submit(new MyTask(1));
        if (!result.isDone()) {//等待结果
            System.out.println("result = " + result.get());
        }

    }

    static class MyTask implements Callable<Integer> {

        private int myCount;

        public MyTask(int count) {
            this.myCount = count;
        }

        @Override
        public Integer call() throws Exception {
            Thread.sleep(1000);
            return myCount + 1;
        }

    }

}

2.线程同步的方法

锁:内置锁（方法锁，对象锁，类锁），
重入锁：

            Lock lock = new ReentrantLock();
                try {
                    lock.lock();
                    。。。。

         } finally {
              lock.unlock();}

synchronized块:
信号量:

/** 
 * 通过以下两种方式获得许可 
 * acquire()  
 * tryAcquire() 
 * @author user 
 * 
 */  
public class SemaphoreTest {  

    private final Set<Integer> set;  

    private final Semaphore sem;  

    public SemaphoreTest(int bound){  
        this.set = Collections.synchronizedSet(new HashSet<Integer>());  
        sem = new Semaphore(bound);       
    }  

    public boolean add(Integer o) throws InterruptedException{  
        sem.acquire(); //如果信号量已被用光阻塞  
        boolean wasAdded = false;  
        try{  
            wasAdded = set.add(o);  
            return wasAdded;  
        } finally {  
            if(!wasAdded){  
                sem.release();  
            }  
        }  
    }  

    public boolean addNoAwait(Integer o) throws InterruptedException{  
        boolean wasAdded = false;  
        if(sem.tryAcquire()){             
            try{  
                wasAdded = set.add(o);  
            } finally {  
                if(!wasAdded){  
                    sem.release();  
                }  
            }  
        }  
        return wasAdded;  
    }  

    public boolean remove (Integer o){  
        boolean wasRemoved = set.remove(o);  
        if(wasRemoved){  
            sem.release();  
        }  
        return wasRemoved;  
    }  

    /** 
     * @param args 
     * @throws InterruptedException  
     */  
    public static void main(String[] args) throws InterruptedException {  
        SemaphoreTest test = new SemaphoreTest(5);  
        for(int i = 0; i < 10; i++){  
//          System.err.println("add " + i + "=" +test.add(i));  
            System.err.println("add " + i + "=" +test.addNoAwait(i));  
        }  
    }  

}  

3.ThreadLocal
-------------

不同线程中访问同一个ThreadLocal的set和get方法，它们对ThreadLocal所做的读写操作仅限于各自线程的内部，这就是为什么ThreadLocal可以在多个线程中互不干扰地存储和修改数据

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

….

public static Looper myLooper() {
    return sThreadLocal.get();
}


4.ThreadPool用法与优势
=================

  引入的好处：
  1）提升性能。创建和消耗对象费时费CPU资源
  2）防止内存过度消耗。控制活动线程的数量，防止并发线程过多。

public class ThreadPool {

private int threadPoolMaxSize;
private List<RunTask> taskQueue;
private WorkThread[] worker;
private static ThreadPool threadPool;

public ThreadPool(int size) {
    this.threadPoolMaxSize = size;
    taskQueue = new LinkedList<RunTask>();
    worker = new WorkThread[size];
    for (int i = 0; i < worker.length; i++) {
        worker[i] = new WorkThread();
        worker[i].start();
    }
}

public static ThreadPool getThreadpool(int size) {
    if (threadPool == null) {
        threadPool = new ThreadPool(size);
    }
    return threadPool;
}

public void destory() {
    for (int i = 0; i < worker.length; i++) {
        worker[i].isRunning = false;
    }
    taskQueue.clear();// ?????清除队列
}

public void addTask(Runnable r) {
    synchronized (taskQueue) {
        taskQueue.add((RunTask) r);
    }
}

class WorkThread extends Thread {
    boolean isRunning = true;

    @Override
    public void run() {
        synchronized (taskQueue) {// ???需要同步
            while (isRunning && !taskQueue.isEmpty()) {
                Runnable runnable = taskQueue.remove(0);
                runnable.run();
            }
        }
    }
}

class RunTask implements Runnable {

    @Override
    public void run() {

        // ....
    }

}

}

5.wait()和sleep()的区别

① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

synchronized(x){
x.notify()
//或者wait()
}
6.生产者消费者模式
采用某种机制保护生产者和消费者之间的同步：

/** 
 * 仓库类Storage实现缓冲区 
 *  
 * Email:530025983@qq.com 
 *  
 * @author MONKEY.D.MENG 2011-03-15 
 *  
 */  
public class Storage  
{  
    // 仓库最大存储量  
    private final int MAX_SIZE = 100;  

    // 仓库存储的载体  
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(  
            100);  

    // 生产num个产品  
    public void produce(int num)  
    {  
        // 如果仓库剩余容量为0  
        if (list.size() == MAX_SIZE)  
        {  
            System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");  
        }  

        // 生产条件满足情况下，生产num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            try  
            {  
                // 放入产品，自动阻塞  
                list.put(new Object());  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  

            System.out.println("【现仓储量为】:" + list.size());  
        }  
    }  

    // 消费num个产品  
    public void consume(int num)  
    {  
        // 如果仓库存储量不足  
        if (list.size() == 0)  
        {  
            System.out.println("【库存量】:0/t暂时不能执行生产任务!");  
        }  

        // 消费条件满足情况下，消费num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            try  
            {  
                // 消费产品，自动阻塞  
                list.take();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  

        System.out.println("【现仓储量为】:" + list.size());  
    }  

    // set/get方法  
    public LinkedBlockingQueue<Object> getList()  
    {  
        return list;  
    }  

    public void setList(LinkedBlockingQueue<Object> list)  
    {  
        this.list = list;  
    }  

    public int getMAX_SIZE()  
    {  
        return MAX_SIZE;  
    }  
}  
----------

/** 
 * 生产者类Producer继承线程类Thread 
 *  
 * Email:530025983@qq.com 
 *  
 * @author MONKEY.D.MENG 2011-03-15 
 *  
 */  
public class Producer extends Thread  
{  
    // 每次生产的产品数量  
    private int num;  

    // 所在放置的仓库  
    private Storage storage;  

    // 构造函数，设置仓库  
    public Producer(Storage storage)  
    {  
        this.storage = storage;  
    }  

    // 线程run函数  
    public void run()  
    {  
        produce(num);  
    }  

    // 调用仓库Storage的生产函数  
    public void produce(int num)  
    {  
        storage.produce(num);  
    }  

    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  

    public void setNum(int num)  
    {  
        this.num = num;  
    }  

    public Storage getStorage()  
    {  
        return storage;  
    }  

    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
}  
/** 
 * 消费者类Consumer继承线程类Thread 
 *  
 * Email:530025983@qq.com 
 *  
 * @author MONKEY.D.MENG 2011-03-15 
 *  
 */  
public class Consumer extends Thread  
{  
    // 每次消费的产品数量  
    private int num;  

    // 所在放置的仓库  
    private Storage storage;  

    // 构造函数，设置仓库  
    public Consumer(Storage storage)  
    {  
        this.storage = storage;  
    }  

    // 线程run函数  
    public void run()  
    {  
        consume(num);  
    }  

    // 调用仓库Storage的生产函数  
    public void consume(int num)  
    {  
        storage.consume(num);  
    }  

    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  

    public void setNum(int num)  
    {  
        this.num = num;  
    }  

    public Storage getStorage()  
    {  
        return storage;  
    }  

    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
}  
/** 
 * <a href="http://lib.youkuaiyun.com/base/softwaretest" class='replace_word' title="软件测试知识库" target='_blank' style='color:#df3434; font-weight:bold;'>测试</a>类Test 
 *  
 * Email:530025983@qq.com 
 *  
 * @author MONKEY.D.MENG 2011-03-15 
 *  
 */  
public class Test  
{  
    public static void main(String[] args)  
    {  
        // 仓库对象  
        Storage storage = new Storage();  

        // 生产者对象  
        Producer p1 = new Producer(storage);  
        Producer p2 = new Producer(storage);  
        Producer p3 = new Producer(storage);  
        Producer p4 = new Producer(storage);  
        Producer p5 = new Producer(storage);  
        Producer p6 = new Producer(storage);  
        Producer p7 = new Producer(storage);  

        // 消费者对象  
        Consumer c1 = new Consumer(storage);  
        Consumer c2 = new Consumer(storage);  
        Consumer c3 = new Consumer(storage);  

        // 设置生产者产品生产数量  
        p1.setNum(10);  
        p2.setNum(10);  
        p3.setNum(10);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);  

        // 设置消费者产品消费数量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  

        // 线程开始执行  
        c1.start();  
        c2.start();  
        c3.start();  
        p1.start();  
        p2.start();  
        p3.start();  
        p4.start();  
        p5.start();  
        p6.start();  
        p7.start();  
    }  
}  


------

【库存量】:0 暂时不能执行生产任务!  
【库存量】:0 暂时不能执行生产任务!  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:17  
【现仓储量为】:19  
【现仓储量为】:20  
【现仓储量为】:21  
【现仓储量为】:22  
【现仓储量为】:23  
【现仓储量为】:24  
【现仓储量为】:25  
【现仓储量为】:26  
【现仓储量为】:12  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:27  
【现仓储量为】:8  
【现仓储量为】:6  
【现仓储量为】:18  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:16  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:3  
【现仓储量为】:15  
【现仓储量为】:1  
【现仓储量为】:0  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:0  
【现仓储量为】:1  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:3  
【现仓储量为】:3  
【现仓储量为】:1  
【现仓储量为】:2  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:18  
【现仓储量为】:19  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:12  
【现仓储量为】:13  
【现仓储量为】:14  
【现仓储量为】:15  
【现仓储量为】:16  
【现仓储量为】:17  
【现仓储量为】:18  
【现仓储量为】:19  
【现仓储量为】:20  
【现仓储量为】:21  
【现仓储量为】:22  
【现仓储量为】:23  
【现仓储量为】:24  
【现仓储量为】:25  
【现仓储量为】:26  
【现仓储量为】:27  
【现仓储量为】:28  
【现仓储量为】:29  
【现仓储量为】:30  
【现仓储量为】:31  
【现仓储量为】:32  
【现仓储量为】:33  
【现仓储量为】:34  
【现仓储量为】:35  
【现仓储量为】:36  
【现仓储量为】:37  
【现仓储量为】:38  
【现仓储量为】:39  
【现仓储量为】:40
Java 线程安全处理详解
m0_38053034的博客
10-18 1691
线程安全是指在多线程环境下，程序的行为能够始终保持一致性和正确性，多个线程同时访问共享资源时，不会导致数据不一致或程序状态异常。线程安全是并发编程中的重要问题，多线程环境下的共享资源访问必须通过适当的同步机制进行控制。Java 提供了多种线程安全处理机制，包括volatile、原子类、显式锁以及并发集合等。在实际开发中，选择合适的线程安全处理方式非常关键。对于简单的同步场景，可以使用和volatile；对于复杂的场景，显式锁和并发集合类提供了更灵活的控制方式。
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 2162
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
Java线程阻塞
qq_43966957的博客
12-06 4995
Java线程阻塞
1、【java线程及线程池系列】java线程及线程池概念详解
热门推荐
alanchanchn的专栏
06-12 6万+
缓冲队列长度的设置，按照一般的理解应该设置成maximumPoolSize的5倍，因为单个线程在不切换cpu的情况下是单个cpu运算一个线程，corePoolSize设置成和cpu一样的数量，maximumPoolSize设置成cpu的2倍，避免cpu处于空闲状态则直接加入一旦cpu空闲理解执行的线程数量，同时由于cpu的速度较快以及有请求执行的线程加入缓冲队列中减少cpu等待时间，故将缓冲队列设置大一些。线程池存在的目的在于提前创建好需要的线程，减少临时创建线程带来的资源消耗。
Java线程同步详解：原理、实现与最佳实践
嗨，欢迎来到我的 优快云 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
04-15 9283
Java线程同步详解：原理、实现与最佳实践
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6470
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java 线程
m0_46698935的博客
04-05 2710
Java 线程 程序：静态代码 安装到硬盘上 进程：运行中的程序 是操作系统分配资源的最小单位 线程：线程是进程（程序）中最小执行单元，是CPU进行调度的最小单位 ​ 一个进程中可以包含多个线程，线程不能脱离进程而存在 ​ 一个线程只能属于一个进程 ​ 例：运行中的 Q Q 进程 ​ 主线程 负责启动程序 例如：Java中的main 启动Java主线程 ​ 一个聊天窗口就是一个线
Java 线程的几种状态
Milliliter___的博客
08-10 1907
在多线程中由于存在线程安全问题，在使用多线程的时候往往会使用锁来避免多线程的安全问题，当同时给多个线程加上同一个锁的时候，这几个线程就会进行锁竞争，当这些线程中有一个线程拿到锁之后，剩下的线程就会进入由锁竞争引起的阻塞状态，此时的状态就是BLOCKED状态。上述代码中创建了两个线程一个t1，一个t2，在t1线程的run方法中通过执行死循环让t1线程一直运行，而t2线程通过t1.join(2000)方法来等待线程t1 2s，2s后t2线程就结束等待，所以t2线程的状态就是TIMED_WAITING。
java 线程的优先级
peinanwei__的博客
05-04 4452
线程优先级 现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。 在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优......
并发编程- (2) Java线程
weixin_51275389的博客
09-03 2093
直接调用run方法不会开启新线程 ==> 不会异步。
Java线程间同步互斥
03-17
Java线程间同步互斥，在实际的编程中，经常要处理线程间的同步互斥问题。Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　...
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程模型缺陷
01-08
Java 编程语言的线程模型可能是此语言中最薄弱的部分。它完全不适合实际复杂程序的要求，而且也完全不是面向对象的。本文建议对 Java 语言进行重大修改和补充，以解决这些问题。 Java 语言的线程模型是此语言的一个...
创变下一浪：穿透具身智能与资本共振下的产业趋势.pdf
08-06
创变下一浪：穿透具身智能与资本共振下的产业趋势.pdf
2023年村级点矢量(WGS84)，详情见主页
08-06
2023年村级点矢量(WGS84)，提供处理服务
LBM_Based-on-Mohamad-in-matlab-master.zip
最新发布
08-06
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
数据库发展研究报告（2025年）.pdf
08-06
数据库发展研究报告（2025年）.pdf
Java线程高级实战指南
"Java线程高级使用教程" 本教程专注于Java线程的高级使用，适合已有一定Java基础，但对多线程和并发编程不太熟悉的开发者。由知名Java专家Brian Goetz撰写，他同时也是developerWorks Java技术专区的定期专栏作家。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值