Java多线程 -- 简单使用

最新推荐文章于 2024-04-19 21:50:42 发布

Uply233

最新推荐文章于 2024-04-19 21:50:42 发布

阅读量244

点赞数

分类专栏： Java 多线程

本文链接：https://blog.csdn.net/Uply233/article/details/81532367

版权

Java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

Future、Callable、Executor简单使用

package com.uply.javanetwork.sb;

import java.util.concurrent.Callable;

/**
 * @author Uply
 * @since 2018/8/9
 */
public class FindMaxTask implements Callable<Integer> {
    private int[] data;
    private int start;
    private int end;

    public FindMaxTask(int[] data, int start, int end) {
        this.data = data;
        this.start = start;
        this.end = end;
    }

    @Override
    public Integer call() throws Exception {
        int max = Integer.MIN_VALUE;
        for(int i = start; i < end; i++)
            if(data[i] > max)
                max = data[i];
        return max;
    }
}

package com.uply.javanetwork.sb;

import com.sun.org.apache.xpath.internal.functions.FuncTranslate;

import javax.persistence.criteria.CriteriaBuilder;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author Uply
 * @since 2018/8/9
 */
public class MultithreadMaxFinder {
    public static int max(int[] data) throws ExecutionException, InterruptedException {
        if(data.length == 1)
            return data[0];
        else if(data.length == 0)
            throw new IllegalArgumentException();
        FindMaxTask task1 = new FindMaxTask(data, 0, data.length / 2);
        FindMaxTask task2 = new FindMaxTask(data, data.length / 2, data.length);
        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<Integer> future1 = service.submit(task1);
        Future<Integer> future2 = service.submit(task2);
        return Math.max(future1.get(), future2.get());
    }
}

这里把Callable对象提交给一个Executor，他会为每个Callable对象创建一个线程（Executor还有其他策略，可以使用一个线程按顺序调用这些callable）

同步

线程通过共享内存、文件句柄、socket和其他资源使得程序更高效。只要两个小陈不同时使用相同的资源，多线程的程序就比多进程程序高效得多，在多进程程序中，每个进程都要为各个资源维护自己的副本。多线程程序的缺点是，如果了两个线程同时访问同一个资源，其中一个就必须等待另一个结束。

同步方法

向方法添加sunchronized修饰符，对当前对象（this引用）同步整个方法。

它回事很多VM性能严重下降。其次，他大大增加了死锁的可能性。第三，并不总是对象本身需要防止同时修改或访问，如果只是对该方法所属类的实例进行同步，可能并不能保护真真需要保护的对象。

优先级

与用户交互的线程应当获得非常高的优先级，这样就能感觉到响应非常快。另一方面，在后天完成计算的线程应当获得低优先级。很快结束的任务应当有高优先级。将花费很长时间的任务应当有低优先级。

抢占

所有Java虚拟机都确保在不同优先级之间使用抢占式线程调度。

为了能让其他线程有机会进行，一个线程有10种方式可以暂停或知识它准备暂停

可以对I/O阻塞
可以对同步对象阻塞
可以放弃
可以休眠
可以连接另一个线程
可以等待一个对象
可以结束
可以被更高优先级线程抢占
可以被挂起
可以停止

要检查每一个run()方法，确保这些条件之一会以合理的频率出现。最后两种可能性已经废弃不用，因为它们会让对象处于不一致的状态。

放弃

要让线程放弃控制权，第二种方式是显示地放弃。为此线程可以通过调用Thread.yield()静态方法来做到。

Thread.yield()会把运行机会交给同优先级的其他线程。yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。

在放弃之前，线程应当确保它或与它关联的Runnale对象处于一致状态，可以由其他对象使用。放弃并不会释放这个线程拥有的所。因此，在线程放弃时不应做任何的同步。

休眠

不管有没有其他线程准备运行，线面线程都会暂停。这样，不只是其他相同优先级的线程得到机会，还会给较低优先级的线程一个运行的机会。不过进入休眠的线程任然拥有它已经获得的所有锁。因此要避免在同步方法或块内让线程休眠。

线程不能绝对保证一定会休眠所期望的那么长时间。有时，在请求唤醒呼叫之后过一段时间线程才回真正唤醒，因为VM正在忙于做其他事情。也可能时间还没到，但有其他线程完成了一些操作唤醒了休眠的线程。一般情况下，这是通过调用休眠线程的interrupt()方法来实现的。

连接线程

Java提供三个join()方法，允许一个线程在据需执行前等待另一个线程结束。

public final old join() throws InterruptedException
public final old join(long milliseconds) throws InterruptedException
public final old join(long milliseconds, int nanoseconds)throws InterruptedException

第一种方法无限等待被连接的线程结束。后面两个方法会等待指定的一段时间，然后会继续执行，即使被连接的线程还没有结束。

连接线程（即调用join()方法的线程）等待被连接的线程（也就是说，调用的是这个线程的join()方法）结束。

连接到另一个线程的线程可以被中断，如果有其他线程调用其interrupt()方法，他就会像休眠线程一样被中断。连接线程的这个调用会抛出一个InterruptedException异常。