JAVA线程

最新推荐文章于 2024-05-01 09:15:00 发布
最新推荐文章于 2024-05-01 09:15:00 发布
阅读量193 收藏
点赞数
分类专栏： 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.csdn.net/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
yaonga
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA线程同步
miqq_79872135的博客
03-23 2900
线程同步 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯定
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 2053
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
探索Java线程副本技术：深入理解与实践ThreadLocal
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 4万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
Java线程系列详解
wang_yong_hui_1234的博客
04-15 4744
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java线程中断
qq_45996900的博客
10-06 3311
1.什么是中断机制？ 2.中断的相关API方法之三大方法说明 3.如何停止中断运行中的线程？ 4.当前线程中的中断标识为true，是不是线程就立即停止？ 5.关于静态方法Thread.interrupted()方法，谈谈你的理解
Java线程详解
csp732171109的博客
12-30 3369
写在最前 线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 Java 给多线程编程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 如果对线程、进程想了解更多的，请阅读 并发编程应知概念详解; 如果对创建线程想了解更多的，请阅读 Jav
Java 线程的使用
weixin_53472653的博客
06-02 3344
尚硅谷学习笔记
Java 线程
m0_46698935的博客
04-05 2626
Java 线程 程序：静态代码 安装到硬盘上 进程：运行中的程序 是操作系统分配资源的最小单位 线程：线程是进程（程序）中最小执行单元，是CPU进行调度的最小单位 ​ 一个进程中可以包含多个线程，线程不能脱离进程而存在 ​ 一个线程只能属于一个进程 ​ 例：运行中的 Q Q 进程 ​ 主线程 负责启动程序 例如：Java中的main 启动Java主线程 ​ 一个聊天窗口就是一个线
Java线程：创建多少线程才是合适的？
ChinaLiaoTian的博客
12-28 4309
Java多线程实战，创建多少线程才是合适的？
java线程异常终止_Java线程异常结束怎么解决
weixin_34220502的博客
02-12 2245
Java中线程异常结束的解决方法是：首先捕获线程执行过程中所产生的异常；然后当线程异常时，会通过调用setUncaughtExceptionHandler方法来捕获异常；最后再解决即可。【推荐教程：Java教程】我们开发工程中经常使用到线程，在线程使用上，我们可能会有这样的场景：(1)伴随这一个业务产生一个比较耗时的任务，而这个业务返回并不需要等待该任务。那我们往往会启动一个线程去完成这个异步任务...
Java线程间同步互斥
03-17
Java线程间同步互斥，在实际的编程中，经常要处理线程间的同步互斥问题。Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　...
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
Java线程模型缺陷
01-08
Java 编程语言的线程模型可能是此语言中最薄弱的部分。它完全不适合实际复杂程序的要求，而且也完全不是面向对象的。本文建议对 Java 语言进行重大修改和补充，以解决这些问题。 Java 语言的线程模型是此语言的一个...
华为智慧城市成功案例集
08-29
华为智慧城市成功案例集
小程序-仁怀酱酒宝：酒类商城模板（源码）.zip
最新发布
08-29
小程序-仁怀酱酒宝：酒类商城模板（源码）.zip
剑雅真题G类雅思官方指南OG剑雅真题G类雅思官方指南OG
08-29
剑雅真题G类雅思官方指南OG剑雅真题G类雅思官方指南OG提取方式是百度网盘分享地址
基于微信小程序的点餐系统的设计设计与实现.docx
08-29
基于微信小程序的点餐系统的设计设计与实现.docx
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值