Java之多线程

33 篇文章 0 订阅
55 篇文章 0 订阅

一、概念

      1、进程(Porcess):

      进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础,每个进程在执行过程中拥有独立的内存单元在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器,由程序、数据和进程控制块三部分组成。程序是指令、数据及其组织形式的描述,而进程是程序的实体。在Java中理解为调用一次main()方法时的整个程序的运行活动。

        1)特性: 

                1>动态性:进程的实质是程序在多道程序系统中的一次执行过程,进程是动态产生,动态消亡的;

                2>并发性:任何进程都可以同其他进程一起并发执行;

                3>独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位;

                4>异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进

        2)主要状态:

                1>就绪状态(Ready):进程已获得除CPU外所需的资源,万事俱备只欠东风。等待分配到CPU资源,只要分配到CPU时进程就可执行。就绪进程可以按多个优先级来划分队列。例如,当一个进程由于时间片用完而进入就绪状态时,排入低优先级队列;当进程由I/O操作完成而进入就绪状态时,排入高优先级队列。

                2>运行状态(Running):进程占用CPU资源。处于此状态的进程的数目小于等于CPU的数目。在没有其他进程可以执行时(比如所有进程都在阻塞状态),通常会自动执行系统的空闲进程。

                3>阻塞状态(Blocked):由于进程等待某种前置依赖条件(如I/O操作或进程同步),在条件满足之前无法继续执行。该事件发生前即使把处理器资源分配给该进程,也无法运行。

      2、线程(Thread):

      线程被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。多个线程共享他们所在进程中的某些内存。一个线程可以创建和撤销另一个线程,同一个进程中的多个线程之间可以并发执行。

辅助理解进程与线程:

        如果把CPU看成是电力,把一台计算机看成一个工厂,把每个进程看成是工厂的每个车间,把每个线程看成是车间里的每个工人。那么:

1、电力(CPU)被分成若干部分分别供各个车间(进程)使用,各车间(进程)之间互不影响;

2、假定该工厂的电表保险丝质量太差,不能让所有车间(进程)同时运转而只能让一个车间(进程)运转。也就是说一个车间(进程)运转时其他车间(进程)必须得歇着,即单个CPU只能运行一个任务,任一时刻CPU总是运行一个进程,其他进程处于非运行状态;

3、车间(进程)中有很有工人(线程),他们协同完成一件任务。

4、车间(进程)的空间(CPU)是工人(线程)共享的,比如许多房间是每个工人(线程)都可以进出的。这象征一个进程的内存空间是共享的,每个线程都可以使用这些共享内存。

5、可是每间房间的大小不同,有些房间最多只能容纳一个人,比如厕所。里面有人的时候,其他人就不能进去了。这代表一个线程使用某些共享内存时,其他线程必须等它结束,才能使用这一块内存。

6、一个防止其他工人进入的简单方法,就是门口加一把锁。先到的人锁上门,后到的人看到上锁,就在门口排队,等锁打开再进去。这就叫"互斥锁"(Mutual exclusion,缩写 Mutex),防止多个线程同时读写某一块内存区域。

7、还有些房间,可以同时容纳n个人,比如厨房。也就是说,如果人数大于n,多出来的人只能在外面等着。这好比某些内存区域,只能供给固定数目的线程使用。

8、这时的解决方法,就是在门口挂n把钥匙。进去的人就取一把钥匙,出来时再把钥匙挂回原处。后到的人发现钥匙没有了,就知道必须在门口排队等着了。这种做法叫做"信号量"(Semaphore),用来保证多个线程不会互相冲突。不难看出,mutex是semaphore的一种特殊情况(n=1时)。也就是说,完全可以用后者替代前者。但是,因为mutex较为简单,且效率高,所以在必须保证资源独占的情况下还是采用这种设计。

操作系统的设计,因此可以归结为三点:

(1)以多进程形式,允许多个任务同时运行;

(2)以多线程形式,允许单个任务分成不同的部分运行;

(3)提供协调机制,一方面防止进程之间和线程之间产生冲突,另一方面允许进程之间和线程之间共享资源。

        1)特性:

                1>轻量级:线程基本上不拥有系统资源,只拥有一点必不可少的、能保证独立运行的资源。故线程的切换非常迅速且开销小(在同一进程中的)。

                2>并发性:线程都可以同其他线程一起并发执行,不管是同进程中的线程还是不同进程中的线程;

                3>共享进程资源:在同一进程中的各个线程,都可以共享该进程所拥有的资源,这首先表现在:所有线程都具有相同的地址空间(进程的地址空间),这意味着,线程可以访问该地址空间的每一个虚地址;此外,还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程内的线程共享内存和文件,所以线程之间互相通信不必调用内核。

        2)状态:

                1>使用继承Thread类或者实现Runnable接口的方式创建线程后,此时创建的线程就是新建状态

                2>当新建状态的线程调用start()方法后就处于就绪状态(即“可运行状态”);

                3>当线程获取到CUP资源后就进入运行状态,在此之后又分5种情况:

                        3.1>当运行状态的线程的run()方法或main()方法执行结束后,线程就处于终止状态

                        3.2>当运行状态的线程调用自身的yield()方法后,意味着主动放弃CPU资源,重新回到就绪状态,与其他就绪状态的线程公平竞争获取CUP资源,系统有可能又把CPU资源再一次分配给该线程;

                        3.3>当运行状态的线程调用自身的sleep()方法或其他线程调用join()方法后当前线程就处于阻塞状态(不释放资源),直到sleep()或join()方法结束后阻塞的线程才自动进入就绪状态,等待时机获取CPU资源继续执行本线程;

                        3.4>当运行状态的线程调用obj的wait()方法后会进入等待队列,不保证顺序(会释放资源),进入这个状态后是不能自动唤醒的,必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只能唤醒一个线程,但我们又不能确定具体唤醒的是哪一个线程,也许我们需要唤醒的线程不能够被唤醒,因此在实际使用中,一般都用notifyAll()方法,唤醒所有线程),线程被唤醒后会进入锁池队列,等待获取锁标记。

                        3.5>当线程刚进入可运行状态,如果发现将要调用的资源被synchronized(同步),获取不到锁标记,将会立即进入锁池状态,等待获取锁标记。这时的锁池里也许已经有了其他线程在等待获取锁标记,这时它们处于锁池队列(先到先得),一旦线程获得锁标记后,才转为可运行状态,等待系统分配CPU时间片;

        进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。

二、线程使用

      当 Java 虚拟机启动时会有某用户线程调用某个指定类的 main 方法,这个线程称为主线程,只有在需要多线程的时候才需要创建线程。获取当前运行的线程的方法是Thread.currentThread()。

1、线程的创建方式:

        1>继承Thread类

class Thread1 extends Thread {
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        int count = 0;
        while (count < 10) {
            System.out.println(threadName + " 的run()方法中第 " + count + " 次循环输出");
            count++;
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        Thread t1 = new Thread1();
        t1.setName("线程 1");
        t1.start();

        Thread t2 = new Thread1();
        t2.setName("线程 2");
        t2.start();
    }
}

输出:

线程 1 的run()方法中第 0 次循环输出
线程 2 的run()方法中第 0 次循环输出
线程 1 的run()方法中第 1 次循环输出
线程 2 的run()方法中第 1 次循环输出
线程 1 的run()方法中第 2 次循环输出
线程 2 的run()方法中第 2 次循环输出
线程 2 的run()方法中第 3 次循环输出
线程 2 的run()方法中第 4 次循环输出
线程 2 的run()方法中第 5 次循环输出
线程 1 的run()方法中第 3 次循环输出
线程 2 的run()方法中第 6 次循环输出
线程 1 的run()方法中第 4 次循环输出
线程 1 的run()方法中第 5 次循环输出
线程 1 的run()方法中第 6 次循环输出
线程 2 的run()方法中第 7 次循环输出
线程 1 的run()方法中第 7 次循环输出
线程 2 的run()方法中第 8 次循环输出
线程 2 的run()方法中第 9 次循环输出
线程 1 的run()方法中第 8 次循环输出
线程 1 的run()方法中第 9 次循环输出

        2>实现Runnable接口

                当使用Runnable接口时,不能直接创建所需类的对象并运行它,必须从 Thread 类的一个实例内部运行它。

class Runnable1 implements Runnable {
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        int count = 0;
        while (count < 10) {
            System.out.println(threadName + " 的run()方法中第 " + count + " 次循环输出");
            count++;
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        Runnable r1 = new Runnable1();

        Thread t1 = new Thread(r1);
        t1.setName("线程 1");
        t1.start();

        Thread t2 = new Thread(r1);
        t2.setName("线程 2");
        t2.start();
    }
}

输出:

线程 1 的run()方法中第 0 次循环输出
线程 2 的run()方法中第 0 次循环输出
线程 1 的run()方法中第 1 次循环输出
线程 2 的run()方法中第 1 次循环输出
线程 1 的run()方法中第 2 次循环输出
线程 1 的run()方法中第 3 次循环输出
线程 1 的run()方法中第 4 次循环输出
线程 1 的run()方法中第 5 次循环输出
线程 1 的run()方法中第 6 次循环输出
线程 2 的run()方法中第 2 次循环输出
线程 2 的run()方法中第 3 次循环输出
线程 1 的run()方法中第 7 次循环输出
线程 1 的run()方法中第 8 次循环输出
线程 1 的run()方法中第 9 次循环输出
线程 2 的run()方法中第 4 次循环输出
线程 2 的run()方法中第 5 次循环输出
线程 2 的run()方法中第 6 次循环输出
线程 2 的run()方法中第 7 次循环输出
线程 2 的run()方法中第 8 次循环输出
线程 2 的run()方法中第 9 次循环输出

        3>实现Callable接口

                Callable接口类似于Runnable,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable功能更强大一些,被线程执行后,可以返回值,这个返回值可以被Future拿到,也就是说,Future可以拿到异步执行任务的返回值。

                FutureTask实现了两个接口,Runnable和Future,所以它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值,那么这个组合的使用有什么好处呢?假设有一个很耗时的返回值需要计算,并且这个返回值不是立刻需要的话,那么就可以使用这个组合,用另一个线程去计算返回值,而当前线程在使用这个返回值之前可以做其它的操作,等到需要这个返回值时,再通过Future得到。

class Callable1 implements Callable<String> {
    @Override
    public String call() {
        String threadName = Thread.currentThread().getName();
        int count = 0;
        while (count < 10) {
            System.out.println(threadName + " 的call()方法中第 " + count + " 次循环输出");
            count++;
        }
        return threadName + " 执行完毕";
    }
}

public class Test3 {
    public static void main(String[] args) {
        Callable<String> c1 = new Callable1();

        FutureTask<String> futureTask1 = new FutureTask<>(c1);
        Thread t1 = new Thread(futureTask1);
        t1.setName("线程 1");

        FutureTask<String> futureTask2 = new FutureTask<>(c1);
        Thread t2 = new Thread(futureTask2);
        t2.setName("线程 2");

        t1.start();
        t2.start();

        try {
            String result1 = futureTask1.get();
            System.out.println(result1);

            String result2 = futureTask2.get();
            System.out.println(result2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出:

线程 1 的call()方法中第 0 次循环输出
线程 1 的call()方法中第 1 次循环输出
线程 1 的call()方法中第 2 次循环输出
线程 1 的call()方法中第 3 次循环输出
线程 2 的call()方法中第 0 次循环输出
线程 1 的call()方法中第 4 次循环输出
线程 1 的call()方法中第 5 次循环输出
线程 1 的call()方法中第 6 次循环输出
线程 1 的call()方法中第 7 次循环输出
线程 1 的call()方法中第 8 次循环输出
线程 1 的call()方法中第 9 次循环输出
线程 2 的call()方法中第 1 次循环输出
线程 2 的call()方法中第 2 次循环输出
线程 2 的call()方法中第 3 次循环输出
线程 1 执行完毕
线程 2 的call()方法中第 4 次循环输出
线程 2 的call()方法中第 5 次循环输出
线程 2 的call()方法中第 6 次循环输出
线程 2 的call()方法中第 7 次循环输出
线程 2 的call()方法中第 8 次循环输出
线程 2 的call()方法中第 9 次循环输出
线程 2 执行完毕

2、线程的命名:

        一个运行中的线程总是有名字的,名字有两个来源:一种是虚拟机默认给的名字,另一种是用户自定义设置的名字。线程都可以调用setName()方法设置线程名字,也可以调用getName()方法获取线程的名字,连主线程也不例外。在没有指定线程名字的情况下,虚拟机总会为线程指定名字。并且主线程的名字总是main,非主线程的名字不确定。

3、线程的分类:

        1>用户线程(User Thread):

        又称前台线程,当有用户线程运行时,JVM不能关闭。当没有用户线程运行时,不管有没有守护线程,JVM都会自动关闭。 默认情况下创建的线程都是用户线程。

        2>守护线程(Daemon Thread):

        又称后台线程,守护线程的作用是为其他线程的运行提供便利服务的,比如垃圾回收线程就是一个很称职的守护者。守护线程一般是由操作系统创建,当然也可以由用户自己创建。在创建完线程之后,在调用start()方法前调用setDaemon(true)方法将该线程设置为守护线程,调用isDaemon()可以判断该线程是否是守护线程。

4、线程的优先级:

        每个线程都有一个优先级,高优先级线程的执行优先于低优先级线程,优先级高的线程会获得较多的运行机会。当设计多线程应用程序的时候,一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的,只能把线程优先级作用作为一种提高程序效率的方法,但是要保证程序不依赖这种优先级规则。

        Java线程的优先级用整数表示,取值范围是1~10,Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。每个线程都有默认的优先级,主线程的默认优先级为Thread.NORM_PRIORITY。Thread类有以下三个静态常量:

        1>static int MAX_PRIORITY:线程可以具有的最高优先级,取值为10;

        2>static int MIN_PRIORITY:线程可以具有的最低优先级,取值为1;

        3>static int NORM_PRIORITY: 分配给线程的默认优先级,取值为5。

5、线程的常用方法:

        1>public void start()

        可以让新建线程变为可运行线程,即准备执行线程中的run()方法。

        2>public static void sleep(long millis)

        在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。

        3>public static void sleep(long millis,int nanos)

        在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)。

        :①线程睡眠是帮助所有线程获得运行机会的最好方法。

               ②线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此sleep()方法不能保证该线程睡眠到期后就开始执行。

        4>public static void yield()

        暂停当前正在执行的线程对象,并执行其他线程。作用是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。但实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。

        5>public final void join()
        等待正在运行的线程终止。让一个线程B“加入”到另外一个线程A的尾部。只有在A执行完毕之后B才能工作。意义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行

        6>public final void join(long millis)

        等待正在运行的线程终止的时间最长为 millis 毫秒,如果超过这个时间,则停止等待,变为可运行状态。意义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行

        7>public final void join(long millis,int nanos)

        等待正在运行的线程终止的时间最长为 millis 毫秒 +nanos 纳秒,如果超过这个时间,则停止等待,变为可运行状态。意义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行

6、阻塞队列:

        1>阻塞队列:java.util.concurrent.BlockingQueue接口,一个指定长度的队列,如果队列满了,添加新元素的操作会被阻塞等待,直到有空位为止。同样,当队列为空时候,请求队列元素的操作同样会阻塞等待,直到有可用元素为止。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Test { 
    public static void main(String[] args) {
        BlockingQueue<Integer> bqueue = new ArrayBlockingQueue<>(5);
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("即将向阻塞队列中添加元素:" + i);
                // 将指定元素添加到此队列中,如果没有可用空间,将一直阻塞等待
                bqueue.put(i);
                System.out.println("向阻塞队列中添加元素:" + i + " 成功");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("程序到此运行结束,即将退出...");
    }
}

输出:

即将向阻塞队列中添加元素:0
向阻塞队列中添加元素:0 成功
即将向阻塞队列中添加元素:1
向阻塞队列中添加元素:1 成功
即将向阻塞队列中添加元素:2
向阻塞队列中添加元素:2 成功
即将向阻塞队列中添加元素:3
向阻塞队列中添加元素:3 成功
即将向阻塞队列中添加元素:4
向阻塞队列中添加元素:4 成功
即将向阻塞队列中添加元素:5

        2>双端阻塞队列:java.util.concurrent.BlockingDeque接口,一个指定长度的队列,两端都可以进出。如果栈满了,添加新元素的操作会被阻塞等待,直到有空位为止。同样,当栈为空时候,请求栈元素的操作同样会阻塞等待,直到有可用元素为止。

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class Test { 
    public static void main(String[] args) {
        BlockingDeque<Integer> bdequeue = new LinkedBlockingDeque<>(5);
        try {
            for (int i = 0; i < 10; i++) {
                if (i % 2 == 0) {
                    System.out.println("即将向双端阻塞队列队首添加元素:" + i);
                    // 将指定元素添加到此队列队首,如果没有可用空间,将一直阻塞等待
                    bdequeue.putFirst(i);
                    System.out.println("向双端阻塞队列队首添加元素:" + i + " 成功");
                } else {
                    System.out.println("即将向双端阻塞队列队尾添加元素:" + i);
                    // 将指定元素添加到此队列队尾,如果没有可用空间,将一直阻塞等待
                    bdequeue.putLast(i);
                    System.out.println("向双端阻塞队列队尾添加元素:" + i + " 成功");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("程序到此运行结束,即将退出...");
    }
}

输出:

即将向双端阻塞队列队首添加元素:0
向双端阻塞队列队首添加元素:0 成功
即将向双端阻塞队列队尾添加元素:1
向双端阻塞队列队尾添加元素:1 成功
即将向双端阻塞队列队首添加元素:2
向双端阻塞队列队首添加元素:2 成功
即将向双端阻塞队列队尾添加元素:3
向双端阻塞队列队尾添加元素:3 成功
即将向双端阻塞队列队首添加元素:4
向双端阻塞队列队首添加元素:4 成功
即将向双端阻塞队列队尾添加元素:5

三、线程同步与锁

        如果多个线程同时访问并修改同一个对象以及它的成员变量时,由于多个线程同时都在修改数据,会造成数据不正确。如:

import lombok.Data;

@Data
public class BankAccount {
    /**
     * 身份证号/客户号
     */
    private String id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 金额
     */
    private Long amount;

    /**
     * 存款
     *
     * @param amount 存款金额
     */
    public void save(Long amount) {
        this.amount = this.amount + amount;
        System.out.println("打生活费:" + amount + ",打款后账户余额:" + this.amount);
    }

    /**
     * 取款
     *
     * @param amount 取款金额
     */
    public void withdraw(Long amount) {
        if (this.amount < amount) {
            System.out.println("取生活费:" + amount + ",取款前账户余额:" + this.amount + ",余额不足");
            return;
        }
        this.amount = this.amount - amount;
        System.out.println("取生活费:" + amount + ",取款后账户余额:" + this.amount);
    }
}
public class Parent extends Thread {
    /**
     * 银行账户
     */
    private BankAccount bankAccount;

    public Parent(BankAccount bankAccount) {
        this.bankAccount = bankAccount;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            this.bankAccount.save(1000L);
        }
    }
}
public class Child extends Thread {
    /**
     * 银行账户
     */
    private BankAccount bankAccount;

    public Child(BankAccount bankAccount) {
        this.bankAccount = bankAccount;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            this.bankAccount.withdraw(1000L);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        BankAccount bankAccount = new BankAccount();
        bankAccount.setId("000001");
        bankAccount.setName("张三");
        bankAccount.setAmount(0L);

        Parent parent = new Parent(bankAccount);
        Child child = new Child(bankAccount);

        parent.start();
        child.start();
    }
}

输出:

打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:1000
打生活费:1000,打款后账户余额:1000
取生活费:1000,取款后账户余额:0
打生活费:1000,打款后账户余额:2000
取生活费:1000,取款后账户余额:1000
取生活费:1000,取款后账户余额:0

        可以看出输出的最后5条结果是不合理的,连续打款2次后余额仍然是1000。原因是两个线程不加控制的访问Foo对象并修改其数据所致。如果要保证结果的正确合理性,需要达到一个要求,那就是将对Bean实例或num的访问加以限制,每次只能有一个线程在访问。这样就能保证Bean对象中数据的合理性了。

        1、锁的概念:Java中每个对象都有一个内置锁,一个对象只有一个锁(更确切地说应该包括“锁”和“钥匙”)。所以如果A线程获得该对象的锁(更确切地说应该是把该对象加了一把锁,手里拿了钥匙),其他线程就都不能访问这个对象(没有打开该对象上锁的钥匙),直到A线程把这个“锁”撤掉。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

        2、信号量(Semaphore):有时被称为信号灯,是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。Semaphore分为单值和多值两种,前者只能被一个线程获得,后者可以被若干个线程获得。单个信号量的Semaphore对象可以实现互斥锁的功能,并且可以是由一个线程获得了“锁”,再由另一个线程释放“锁”,这可应用于死锁恢复的一些场合。

               以停车场为例:假设停车场只有三个车位,一开始三个车位都是空的。这时如果同时来了五辆车,看门人允许其中三辆不受阻碍的进入,然后放下车拦,剩下的车则必须在入口等待,此后来的车也都不得不在入口处等待。这时,有一辆车离开停车场,看门人得知后,打开车拦,放入一辆,如果又离开两辆,则又可以放入两辆,如此往复。在这个停车场系统中,车位是公共资源,每辆车好比一个线程,看门人起的就是信号量的作用。

               信号量的特性如下:信号量是一个非负整数(车位数),所有通过它的线程(车辆)都会将该整数减一(通过它当然是为了使用资源),当该整数值为零时,所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作: Request(请求)和 Release(释放)。 当一个线程调用Request(请求)操作时,它要么通过然后将信号量减一,要么一直等下去,直到信号量大于1或超时。Release(释放)实际上是在信号量上执行加操作,对应于车辆离开停车场,该操作之所以叫做“释放”是因为加操作实际上是释放了由信号量守护的资源。

               信号量还可以设置是否采用公平模式,如果采用公平模式,则线程将会按到达的顺序(FIFO)执行;如果是非公平模式,则后请求的有可能排在队列的头部。构造方法是:Semaphore(int permits, boolean fair)。使用方法如下:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class Test { 
	public static void main(String[] args) {
        // 线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        // 只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);
        // 模拟20个客户端访问
        for (int index = 0; index < 10; index++) {
            final int NO = index;
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 获取许可
                        semp.acquire();
                        System.out.println("第" + NO+"位进入");
                        
                        Thread.sleep((long) (Math.random() * 10000));
                        // 访问完后,释放
                        semp.release();
                      //availablePermits()指的是当前信号灯库中有多少个可以被使用
                        System.out.println("可用信号量为:" + semp.availablePermits()); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            pool.execute(run);
        }
        // 退出线程池
        pool.shutdown();
    }
} 

输出:

第0位进入
第2位进入
第1位进入
第3位进入
第4位进入
第5位进入
可用信号量为:0
可用信号量为:1
第6位进入
可用信号量为:1
第7位进入
可用信号量为:1
第8位进入
可用信号量为:1
第9位进入
可用信号量为:1
可用信号量为:2
可用信号量为:3
可用信号量为:4
可用信号量为:5

        3、同步的四种机制:

                1>使用synchronized关键字修饰方法或块

           当程序运行到非静态的synchronized方法或块上时,自动获得当前实例对象的锁,直到退出synchronized方法或块才释放锁。

        如果线程试图进入同步方法,而其锁已经被占用,则线程在该对象上被阻塞。实质上线程进入该对象的一种池中(锁池队列),必须在那里等待,直到其锁被释放,该线程才能再次变为可运行或运行状态。

        wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样,每个对象可以有一个线程列表,这些线程等待来自该对象的信号(通知)。对象调用wait()方法获得这个等待列表。至此该对象不再执行任何该等待队列中线程中的动作,直到调用对象的notify()方法。如果多个线程在同一个对象上等待,则将只选择一个线程(不保证以何种顺序)继续执行。如果没有线程等待,则不采取任何特殊操作。使用wait()、notify()、notifyAll()方法时必须从同步块内调用这些方法:

        1>public final void wait()

        使已获取对象锁的当前线程释放对象锁,重新进入等待队列而成为等待状态;

        2>public final void notify()

        当前线程放弃此对象上的锁定后,才能继续执行被唤醒在此对象上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程,选择是任意性的;

        3>public final void notifyAll()

        当前线程放弃此对象上的锁定后,才能继续执行被唤醒在此对象上等待的所有线程。被唤醒的所有线程将以常规方式在锁池队列中进行竞争。

package test2;
class Bean{
}
class Thread1 extends Thread{
	private String name;
	private Bean bean;
	public Thread1(String name,Bean bean){
		this.name=name;
		this.bean=bean;
	}
	public void run() {
		this.setName(name);
		synchronized (bean) {
			try {
				System.out.println("线程"+Thread.currentThread().getName()+"获得bean的锁");
				Thread.sleep(3000);
				System.out.println("线程"+Thread.currentThread().getName()+"调用bean的wait()方法");
				Thread.sleep(3000);
				bean.wait();
				System.out.println("线程"+Thread.currentThread().getName()+"即将死亡");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class Thread2 extends Thread{
	private String name;
	private Bean bean;
	public Thread2(String name,Bean bean){
		this.name=name;
		this.bean=bean;
	}
	public void run() {
		this.setName(name);
		synchronized (bean) {
			try {
				System.out.println("线程"+Thread.currentThread().getName()+"获得bean的锁");
				Thread.sleep(3000);
				System.out.println("线程"+Thread.currentThread().getName()+"调用bean的notify()方法");
				Thread.sleep(3000);
				bean.notify();
				System.out.println("线程"+Thread.currentThread().getName()+"即将死亡");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class Thread3 extends Thread{
	private String name;
	private Bean bean;
	public Thread3(String name,Bean bean){
		this.name=name;
		this.bean=bean;
	}
	public void run() {
		this.setName(name);
		synchronized (bean) {
			try {
				System.out.println("线程"+Thread.currentThread().getName()+"获得bean的锁");
				Thread.sleep(3000);
				System.out.println("线程"+Thread.currentThread().getName()+"调用bean的notifyAll()方法");
				Thread.sleep(3000);
				bean.notifyAll();
				System.out.println("线程"+Thread.currentThread().getName()+"即将死亡");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
public class Test5 {
	public static void main(String[] args) {
		Bean bean = new Bean();
		Thread1 thread1 = new Thread1("Thread1",bean);
		Thread2 thread2 = new Thread2("Thread2",bean);
		Thread3 thread3 = new Thread3("Thread3",bean);
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

结果:

线程Thread1获得bean的锁
线程Thread1调用bean的wait()方法
线程Thread3获得bean的锁
线程Thread3调用bean的notifyAll()方法
线程Thread3即将死亡
线程Thread2获得bean的锁
线程Thread2调用bean的notify()方法
线程Thread2即将死亡
线程Thread1即将死亡

可以看出:当在对象上调用wait()方法时,执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时或notifyAll()时,并不意味着当前线程会放弃其锁。因此调用notify()并不意味着对象锁变得可用。

注意:①synchronized只能修饰方法或块;

           ②不必同步类中所有的方法,类可以同时拥有同步和非同步方法;

           ③线程睡眠时,它所持的任何锁都不会释放;

           ④线程可以获得多个锁。比如在一个对象的同步方法里面调用另外一个对象的同步方法,则获取了两个对象的同步锁;

           ⑤同步损害并发性,应该尽可能缩小同步范围。同步不但可以同步整个方法,还可以同步方法中一部分代码块;

           ⑥如果两个线程要执行一个类中的synchronized方法,并且两个线程使用相同的实例来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。也就是说:如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。

                ⑦要明确在哪个对象上同步。在使用同步代码块时候,应该指定在哪个对象上同步,也就是说要指定获取哪个对象的锁。比如:

public synchronized void setNum(int tmp) {
	num = num-tmp;
}

public void setNum(int tmp) {
	synchronized(this){
		num = num-tmp;
	}
}

效果完全一样。

           ⑧同步静态方法,需要一个用于整个类对象的锁:

public static synchronized void setNum(int tmp) {
	num = num-tmp;
}

public static void setNum(int tmp) {
	synchronized(Bean.class){
		num = num-tmp;
	}
}

           ⑨静态同步方法和非静态同步方法将永远不会彼此阻塞,因为静态方法锁定在Class对象上,非静态方法锁定在该类的对象上。

           ⑩当一个类已经很好的同步以保护它的数据时,这个类就称为“线程安全的”。即使是线程安全类,也应该特别小心,因为操作的线程之间仍然不一定安全。

另外:在使用synchronized关键字时候,应该尽可能避免在synchronized方法或synchronized块中使用sleep方法,因为synchronized程序块占着对象锁,你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率,也不合逻辑。

同样,在同步程序块内调用yeild方法让出CPU资源也没有意义,因为你占用着锁,其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间

                2>使用volatile关键字修饰变量

        volatile在高性能的多线程程序中也有很重要的用途,只是这个关键字用不好会出很多问题。

        为什么变量需要volatile来修饰呢?比如做一个i++操作,计算机内部做了三次处理:读取-修改-写入。同样,对于一个long型数据,做了个赋值操作,在32系统下需要经过两步才能完成,先修改低32位,然后修改高32位。假想一下,当将以上的操作放到一个多线程环境下操作时候,有可能出现的问题:如果这些步骤只执行了一部分,而另外一个线程就已经引用了变量值,这样就导致了读取脏数据的问题。通过这个设想,就不难理解volatile关键字了。volatile可以用在任何变量前面,但不能用于final变量前面,因为final型的变量是禁止修改的。也不存在线程安全的问题。

                3>使用Lock接口

        ①java.util.concurrent.locks.Lock接口:实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的Condition对象。 不区分读写,称为“普通锁”;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//信用卡账户,可随意透支 
class MyCount { 
    private String oid;         //账号 
    private int cash;           //账户余额 
    MyCount(String oid, int cash) { 
        this.oid = oid; 
        this.cash = cash; 
    } 
    public String getOid() { 
        return oid; 
    } 
    public void setOid(String oid) { 
        this.oid = oid; 
    } 
    public int getCash() { 
        return cash; 
    } 
    public void setCash(int cash) { 
        this.cash = cash; 
    } 
    public String toString() { 
        return "帐户信息:[帐号:"+oid+",余额:"+cash+"]"; 
    } 
}
//信用卡的用户 
class User implements Runnable { 
    private String name;            //用户名 
    private MyCount myCount;        //所要操作的账户 
    private int iocash;             //操作的金额,当然有正负之分了 
    private Lock myLock;            //执行操作所需的锁对象 
    User(String name, MyCount myCount, int iocash, Lock myLock) { 
        this.name = name; 
        this.myCount = myCount; 
        this.iocash = iocash; 
        this.myLock = myLock; 
    } 
    public void run() { 
        //获取锁 
        myLock.lock(); 
        //执行现金业务 
        System.out.println(myCount +","+ name + "正在操作账户,金额为" + iocash); 
        myCount.setCash(myCount.getCash() + iocash); 
        System.out.println(name + "操作账户成功,当前金额为" + myCount.getCash()); 
        //释放锁,否则别的线程没有机会执行了 
        myLock.unlock(); 
    } 
} 
public class Test { 
    public static void main(String[] args) { 
        //创建并发访问的账户 
        MyCount myCount = new MyCount("0000000000000000", 10000); 
        //创建一个锁对象 
        Lock lock = new ReentrantLock(); 
        //创建一个线程池 
        ExecutorService pool = Executors.newCachedThreadPool(); 
        //创建一些并发访问用户,一个信用卡,存的存,取的取 
        User u1 = new User("张三", myCount, -4000, lock); 
        User u2 = new User("张三他爹", myCount, 6000, lock); 
        User u3 = new User("张三他弟", myCount, -8000, lock); 
        User u4 = new User("张三", myCount, 800, lock); 
        //在线程池中执行各个用户的操作 
        pool.execute(u1); 
        pool.execute(u2); 
        pool.execute(u3); 
        pool.execute(u4); 
        //关闭线程池 
        pool.shutdown(); 
    } 
}

输出:

帐户信息:[帐号:0000000000000000,余额:10000],张三正在操作账户,金额为-4000
张三操作账户成功,当前金额为6000
帐户信息:[帐号:0000000000000000,余额:6000],张三正在操作账户,金额为800
张三操作账户成功,当前金额为6800
帐户信息:[帐号:0000000000000000,余额:6800],张三他弟正在操作账户,金额为-8000
张三他弟操作账户成功,当前金额为-1200
帐户信息:[帐号:0000000000000000,余额:-1200],张三他爹正在操作账户,金额为6000
张三他爹操作账户成功,当前金额为4800

        ②java.util.concurrent.locks.ReentrantReadWriteLock类:为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,称为“读写锁”。构造方法中可设置“公平模式”与“非公平模式”。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

//信用卡账户,可随意透支 
class MyCount { 
    private String oid;           //账号 
    private int cash;             //账户余额 
    MyCount(String oid, int cash) { 
        this.oid = oid; 
        this.cash = cash; 
    } 
    public String getOid() { 
        return oid; 
    } 
    public void setOid(String oid) { 
        this.oid = oid; 
    } 
    public int getCash() { 
        return cash; 
    } 
    public void setCash(int cash) { 
        this.cash = cash; 
    } 
    public String toString() { 
    	return "帐户信息:[帐号:"+oid+",余额:"+cash+"]";
    } 
}
//信用卡的用户 
class User implements Runnable { 
    private String name;                //用户名 
    private MyCount myCount;            //所要操作的账户 
    private int iocash;                 //操作的金额,当然有正负之分了 
    private ReadWriteLock myLock;       //执行操作所需的锁对象 
    private boolean isQuery;            //是否是查询帐户 
    User(String name, MyCount myCount, int iocash, ReadWriteLock myLock, boolean isQuery) { 
        this.name = name; 
        this.myCount = myCount; 
        this.iocash = iocash; 
        this.myLock = myLock; 
        this.isQuery = isQuery; 
    } 
    public void run() { 
        if (isQuery) { 
            //获取读锁 
            myLock.readLock().lock(); 
            System.out.println(myCount +","+ name + "正在查询账户余额"); 
            //释放读锁 
            myLock.readLock().unlock(); 
        } else { 
            //获取写锁 
            myLock.writeLock().lock(); 
            //执行现金业务 
            System.out.println(myCount +","+ name + "正在进行存取操作,存取金额为" + iocash); 
            myCount.setCash(myCount.getCash() + iocash); 
            System.out.println(name + "操作账户成功,当前金额为" + myCount.getCash()); 
            //释放写锁 
            myLock.writeLock().unlock(); 
        } 
    } 
} 
public class Test { 
    public static void main(String[] args) { 
        //创建并发访问的账户 
        MyCount myCount = new MyCount("0000000000000000", 10000); 
        //创建一个锁对象 
        ReadWriteLock lock = new ReentrantReadWriteLock(false); 
        //创建一个线程池 
        ExecutorService pool = Executors.newFixedThreadPool(2); 
        //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊 
        User u1 = new User("张三", myCount, -4000, lock, false); 
        User u2 = new User("张三他爹", myCount, 6000, lock, false); 
        User u3 = new User("张三他弟", myCount, -8000, lock, false); 
        User u4 = new User("张三", myCount, 800, lock, false); 
        User u5 = new User("张三他爹", myCount, 0, lock, true); 
        //在线程池中执行各个用户的操作 
        pool.execute(u1); 
        pool.execute(u2); 
        pool.execute(u3); 
        pool.execute(u4); 
        pool.execute(u5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
}

输出:

帐户信息:[帐号:0000000000000000,余额:10000],张三正在进行存取操作,存取金额为-4000
张三操作账户成功,当前金额为6000
帐户信息:[帐号:0000000000000000,余额:6000],张三他爹正在进行存取操作,存取金额为6000
张三他爹操作账户成功,当前金额为12000
帐户信息:[帐号:0000000000000000,余额:12000],张三他弟正在进行存取操作,存取金额为-8000
张三他弟操作账户成功,当前金额为4000
帐户信息:[帐号:0000000000000000,余额:4000],张三正在进行存取操作,存取金额为800
张三操作账户成功,当前金额为4800
帐户信息:[帐号:0000000000000000,余额:4800],张三他爹正在查询账户余额

        ③java.util.concurrent.locks.Condition接口:条件变量将 Object 的方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用。条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的,这样,条件就和一个锁对象绑定起来了。因此Java中的条件变量只能和锁配合使用,来控制并发程序访问竞争资源的安全。

        条件变量常用方法

        1)void await():使当前线程处于等待状态直到被唤醒。

        2)void signal():唤醒一个等待线程,如果所有的线程都在等待此条件,则选择其中的一个唤醒。

        3)void signalAll():唤醒所有等待线程,如果所有的线程都在等待此条件,则唤醒所有线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//普通银行帐户,不可透支
class MyCount { 
    private String oid;                               //账号 
    private int cash;                                 //账户余额 
    private Lock lock = new ReentrantLock();          //账户锁 
    private Condition saveCondition = lock.newCondition();    //存款条件 
    private Condition drawCondition = lock.newCondition();    //取款条件 
    MyCount(String oid, int cash) { 
        this.oid = oid; 
        this.cash = cash; 
    } 
    //存款
    public void saving(int x, String name) { 
        lock.lock();                          //获取锁 
        if (x > 0) { 
            cash += x;                       //存款 
            System.out.println(name + "存款" + x + ",存款之后余额为" + cash); 
        } 
        drawCondition.signalAll();           //唤醒所有等待线程。 
        lock.unlock();                       //释放锁 
    } 
    //取款
    public void drawing(int x, String name) { 
        lock.lock();                          //获取锁 
        try { 
            if (cash - x < 0) { 
            	System.out.println(name + "取款" + x + ",但余额只有" + cash +",余额不足"); 
                drawCondition.await();        //余额不足,阻塞取款操作 
            } else { 
                cash -= x;                    //取款 
                System.out.println(name + "取款" + x + ",取款之后余额为" + cash); 
            } 
            saveCondition.signalAll();        //唤醒所有存款操作 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } finally { 
            lock.unlock();                    //释放锁 
        } 
    } 
}
//存款线程类 
class SaveThread extends Thread { 
    private String name;                //操作人 
    private MyCount myCount;            //账户 
    private int x;                      //存款金额 
    SaveThread(String name, MyCount myCount, int x) { 
        this.name = name; 
        this.myCount = myCount; 
        this.x = x; 
    } 
    public void run() { 
        myCount.saving(x, name); 
    } 
} 
//取款线程类
class DrawThread extends Thread { 
    private String name;             //操作人 
    private MyCount myCount;         //账户 
    private int x;                   //存款金额 

    DrawThread(String name, MyCount myCount, int x) { 
        this.name = name; 
        this.myCount = myCount; 
        this.x = x; 
    } 

    public void run() { 
        myCount.drawing(x, name); 
    } 
} 
public class Test { 
    public static void main(String[] args) { 
        //创建并发访问的账户 
        MyCount myCount = new MyCount("0000000000000000", 10000); 
        //创建一个线程池 
        ExecutorService pool = Executors.newFixedThreadPool(2); 
        Thread t1 = new DrawThread("张三", myCount, 9000); 
        Thread t2 = new SaveThread("李四", myCount, 3600); 
        Thread t3 = new DrawThread("王五", myCount, 8000); 
        Thread t4 = new SaveThread("老张", myCount, 600); 
        Thread t5 = new DrawThread("老牛", myCount, 2000); 
        Thread t6 = new DrawThread("胖子", myCount, 800); 
        //执行各个线程 
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        pool.execute(t6); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

张三取款9000,取款之后余额为1000
王五取款8000,但余额只有1000,余额不足
李四存款3600,存款之后余额为4600
老张存款600,存款之后余额为5200
老牛取款2000,取款之后余额为3200
胖子取款800,取款之后余额为2400

           4>使用原子量java.util.concurrent.atomic包中的变量类型

        原子量虽然可以保证单个变量在某一个操作过程的安全,但无法保证整个代码块,或者整个程序的安全性。因此,通常还应该使用锁等同步机制来控制整个程序的安全性。

定义原子量的方法形如:

private static AtomicLong aLong = new AtomicLong(10000);        

四、线程死锁

       当两个线程被阻塞,每个线程在等待另一个线程时就发生死锁。比如:

class Bean{
	private int num=100;
	public int getNum(){
		return num;
	}
	public void setNum(int num){
		this.num=num;
	}
}

public class Test4{
	Bean bean1 = new Bean();
	Bean bean2 = new Bean();
	Thread t1 = new Thread(new Runnable(){
		public void run(){
			int count=1;
			while(count<=3){
				synchronized(bean1){
					synchronized(bean2){
						System.out.println(bean2.getNum());
					}
				}
				count++;
			}
		}
	});
	Thread t2 = new Thread(new Runnable(){
		public void run(){
			int count=1;
			while(count<=3){
				synchronized(bean2){
					synchronized(bean1){
						bean1.setNum(200);
						System.out.println(bean1.getNum());
					}
				}
				count++;
			}
		}
	});
	public static void main(String[] args) {
		Test4 test4= new Test4();
		test4.t1.start();
		test4.t2.start();
	}
}

Thread1和Thread2的实例在访问bean1和bean2时就有可能发生死锁。发生死锁也是概率发生的,比如大多数情况的运行结果是:

100
100
100
200
200
200

但也会出现如下这种只有一条记录的死锁情况:

100

五、障碍器

        为了适应一种新的设计需求,比如一个大型的任务,常常需要分配好多子任务去执行,只有当所有子任务都执行完成时候,才能执行主任务,这时候就可以选择障碍器了。构造方法如下:

        1、public CyclicBarrier(int parties):创建一个 CyclicBarrier对象,它将在给定数量的参与者(线程)处于等待状态时启动,但它不会在启动 barrier 时执行预定义的操作。

        2、public CyclicBarrier(int parties,Runnable barrierAction):创建一个 CyclicBarrier对象,它将在给定数量的参与者(线程)处于等待状态时启动,并在启动 barrier 时执行给定的屏障操作,该操作由最后一个进入 barrier 的线程执行。 

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

//主任务
class MainTask implements Runnable { 
    public void run() { 
        System.out.println("主任务开始执行..."); 
        System.out.println("主任务结束执行..."); 
    } 
} 
//子任务
class SubTask extends Thread { 
    private String name; 
    private CyclicBarrier cb; 
    SubTask(String name, CyclicBarrier cb) { 
        this.name = name; 
        this.cb = cb; 
    } 
    public void run() { 
        try {
        	System.out.println("[子任务" + name + "]开始执行..."); 
			System.out.println("[子任务" + name + "]开始执行完成了,并通知障碍器已经完成!"); 
			cb.await(); 
		} catch (InterruptedException e) { 
                e.printStackTrace(); 
        } catch (BrokenBarrierException e1) { 
                e1.printStackTrace(); 
        } 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建障碍器,并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable) 
        CyclicBarrier cb = new CyclicBarrier(2, new MainTask()); 
        new SubTask("A", cb).start(); 
        new SubTask("B", cb).start(); 
        new SubTask("C", cb).start(); 
        new SubTask("D", cb).start(); 
        new SubTask("E", cb).start(); 
        new SubTask("F", cb).start(); 
        new SubTask("G", cb).start(); 
    } 
} 

输出:

[子任务A]开始执行...
[子任务A]开始执行完成了,并通知障碍器已经完成!
[子任务C]开始执行...
[子任务C]开始执行完成了,并通知障碍器已经完成!
[子任务D]开始执行...
主任务开始执行...
[子任务D]开始执行完成了,并通知障碍器已经完成!
主任务结束执行...
[子任务F]开始执行...
[子任务F]开始执行完成了,并通知障碍器已经完成!
[子任务B]开始执行...
主任务开始执行...
主任务结束执行...
[子任务E]开始执行...
[子任务E]开始执行完成了,并通知障碍器已经完成!
[子任务B]开始执行完成了,并通知障碍器已经完成!
主任务开始执行...
主任务结束执行...
[子任务G]开始执行...
[子任务G]开始执行完成了,并通知障碍器已经完成!

六、线程池

        线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。

        java.util.concurrent.Executors类中提供了有关线程池的方法:

       1、固定尺寸的线程池

           1>public static ExecutorService newFixedThreadPool(int nThreads)

            2>public static ExecutorService newFixedThreadPool(int nThreads,ThreadFactory threadFactory)

用法:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread extends Thread{ 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
    	Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName()+"正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建一个可重用固定线程数的线程池 
        ExecutorService pool = Executors.newFixedThreadPool(2); 
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

ThreadB正在执行...
ThreadA正在执行...
ThreadD正在执行...
ThreadE正在执行...
ThreadC正在执行...

        2、单任务线程池

            1>public static ExecutorService newSingleThreadExecutor()

            2>public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

用法:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread extends Thread{ 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
    	Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName()+"正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建一个可重用单任务线程池 
        ExecutorService pool = Executors.newSingleThreadExecutor(); 
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

ThreadA正在执行...
ThreadB正在执行...
ThreadC正在执行...
ThreadD正在执行...
ThreadE正在执行...

       对于以上两种连接池,大小都是固定的,当要加入池的线程(或者任务)超过池最大尺寸时候,则入此线程池需要排队等待。一旦池中有线程完毕,则排队等待的某个线程会入池执行。

        3、可变尺寸的线程池

            1>public static ExecutorService newCachedThreadPool()

            2>public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
用法:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread extends Thread{ 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
    	Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName()+"正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建一个可变大小的线程池 
        ExecutorService pool = Executors.newCachedThreadPool(); 
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

ThreadA正在执行...
ThreadC正在执行...
ThreadB正在执行...
ThreadD正在执行...
ThreadE正在执行...

        4、延迟线程池

            1>public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

            2>public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,ThreadFactory threadFactory)
用法:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class MyThread extends Thread{ 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
    	Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName()+"正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建一个可安排在给定延迟后运行命令或者定期地执行的线程池 
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.schedule(t2, 10, TimeUnit.MILLISECONDS); 
        pool.execute(t3); 
        pool.schedule(t4, 10, TimeUnit.MILLISECONDS); 
        pool.execute(t5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

ThreadA正在执行...
ThreadC正在执行...
ThreadE正在执行...
ThreadB正在执行...
ThreadD正在执行...

        5、单任务延迟线程池

            1>public static ScheduledExecutorService newSingleThreadScheduledExecutor()

            2>public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
用法:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class MyThread extends Thread{ 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
    	Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName()+"正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建一个可安排在给定延迟后运行命令或者定期地执行的单任务线程池 
        ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.schedule(t2, 10, TimeUnit.MILLISECONDS); 
        pool.execute(t3); 
        pool.schedule(t4, 10, TimeUnit.MILLISECONDS); 
        pool.execute(t5); 
        //关闭线程池 
        pool.shutdown(); 
    } 
} 

输出:

ThreadA正在执行...
ThreadC正在执行...
ThreadE正在执行...
ThreadB正在执行...
ThreadD正在执行...

        6、自定义线程池

        创建自定义线程池的构造方法有4个,参数最完整的构造方法是:

public ThreadPoolExecutor(int corePoolSize,      //池中所保存的核心线程数,包括空闲线程
                          int maximumPoolSize,   //池中允许的最大线程数
                          long keepAliveTime,    //当线程数大于池中核心线程数时,多余的空闲线程等待新任务的最长时间,如果时间到还无任务则终止
                          TimeUnit unit,         //时间参数的时间单位
                          BlockingQueue<Runnable> workQueue, //阻塞队列,用于存放执行前处于等待的线程队列,此队列仅保持由execute方法提交的Runnable任务
                          ThreadFactory threadFactory,       //创建新线程时使用的工厂
                          RejectedExecutionHandler handler)  //由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序

        抛出:
        1>IllegalArgumentException:

                如果 corePoolSize 或 keepAliveTime 小于零,或者 maximumPoolSize 小于或等于零,或者 corePoolSize 大于 maximumPoolSize。
        2>NullPointerException:

                如果 workQueue 为 null  

        自定义线程池稍微麻烦些,不过通过创建的ThreadPoolExecutor线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。

用法:

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.BlockingQueue; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

class MyThread extends Thread { 
	private String name;
	public MyThread(String name){
		this.name=name;
	}
    public void run() { 
        Thread.currentThread().setName(name);
		System.out.println(Thread.currentThread().getName() + "正在执行..."); 
    } 
}
public class Test { 
    public static void main(String[] args) { 
        //创建等待队列 
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20); 
        //创建一个自定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue); 
        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 
        Thread t1 = new MyThread("ThreadA"); 
        Thread t2 = new MyThread("ThreadB"); 
        Thread t3 = new MyThread("ThreadC"); 
        Thread t4 = new MyThread("ThreadD"); 
        Thread t5 = new MyThread("ThreadE"); 
        Thread t6 = new MyThread("ThreadF"); 
        Thread t7 = new MyThread("ThreadG"); 
        //将线程放入池中进行执行 
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        pool.execute(t6); 
        pool.execute(t7); 
        //关闭线程池 
        pool.shutdown(); 
    } 
}

输出:

ThreadB正在执行...
ThreadA正在执行...
ThreadC正在执行...
ThreadD正在执行...
ThreadE正在执行...
ThreadF正在执行...
ThreadG正在执行...

参考:http://lavasoft.blog.51cto.com/62575/222742

            http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

            http://www.cnblogs.com/linjiqin/archive/2013/07/25/3214676.html

  • 0
    点赞
  • 0
    收藏
  • 打赏
    打赏
  • 2
    评论

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 2

打赏作者

鹤啸九天-西木

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值