高级多线程笔记

高级多线程

线程池概念

问题：

线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。

频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。

线程池：

线程容器，可设定线程分配的数量上限。将预先创建的线程对象存入池中，并重用线程池中的线程对象。避免频繁的创建和销毁。

创建线程池

常用的线程池接口和类(所在包java.util.concurrent):

Executor:线程池的顶级接口。
ExecutorService:线程池接口，可通过submit(Runnable task)提交任务代码。
Executors工具类:通过此类可以获得一个线程池。
通过newFixedThreadPool(int nThreads)获取固定数量的线程池。参数:指定线程池中线程的数量。
通过newCachedThreadPool()获得动态数量的线程池，如不够则创建新的，没有上限

Executor：线程池的根接口，execute()
ExecutorService：包含管理线程池的一些方法，submit shutdown
ThreadPoolExecutor
ScheduledThreadPoolExecutor
Excutors:创建像城池工具类
(1)创建固定线程个数线程池
(2)创建缓存线程池，由任务的多少决定
(3)创建单线程池
(4)创建调度线程池 调度：周期，定时执行

package Thread3;

/**Executor：线程池的根接口，execute()
ExecutorService：包含管理线程池的一些方法，submit shutdown
ThreadPoolExecutor
ScheduledThreadPoolExecutor
Excutors:创建像城池工具类
 (1)创建固定线程个数线程池
 (2)创建缓存线程池，由任务的多少决定
 (3)创建单线程池
 (4)创建调度线程池 调度：周期，定时执行
*/

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

public class Demo01 {
    public static void main(String[] args) {
        //1创建固定线程个数的线程池
        //ExecutorService es = Executors.newFixedThreadPool(4);
        //1.2创建缓存线程池，线程个数由任务个数决定
        ExecutorService es = Executors.newCachedThreadPool();
        //2创建任务
        Runnable runnable = new Runnable() {
            private int ticket = 100;
            @Override
            public void run() {
                while(true){
                    if (ticket<=0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
                    ticket--;
                }
            }
        };
        //3提交任务
        for (int i = 0;i<4;i++){
            es.submit(runnable);
        }
        //4关闭线程
        es.shutdown();//等待所有任务执行完毕然后关闭线程池
    }
}

Callable接口

public interface Vallable{

public V call() throws Exception;

}

JDK5加入，与Runnable接口类似，实现之后代表一个线程任务。

Callable具有泛型返回值、可以声明异常。

演示Callable接口的使用
Callable和Runnable接口的区别
(1)Callable接口中call方法有返回值,Runnable接口中run方法没有返回值

(2)Callable接口中call方法有声明异常，Runnable接口中run方法没有异常

package Thread3;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //功能需求：使用Callable实现1-100和
        Callable<Integer> callable = new Callable<Integer>(){

            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算");
                int sum = 0;
                for (int i = 0;i<=100;i++){
                    sum = sum + i;
                    Thread.sleep(100);
                }
                return sum;
            }
        };
        //2把Callable对象转成可执行任务
        FutureTask<Integer> task = new FutureTask<>(callable);
        //3创建线程
        Thread thread = new Thread(task);
        //4创建线程
        thread.start();
        //5获取结果(等待call执行完毕，才会返回)
        Integer sum = task.get();
        System.out.println("结果是："+sum);
    }
}

Callable结合线程池使用

package Thread3;
//使用线程池计算1-100的和

import java.util.concurrent.*;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        //1创建线程池
        ExecutorService es = Executors.newFixedThreadPool(1);
        //2提交任务 Future：表示将要执行完成任务的结果
        Future<Integer> future = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算");
                int sum = 0;
                for (int i = 0;i<=100;i++){
                    sum+=i;
                }
                return sum;
            }
        });
        //3获取任务结果
        System.out.println(future.get());
        //4关闭线程池
        es.shutdown();
    }
}

Future接口

Future:表示将要完成任务的结果。

需求：使用两个线程，并发计算1_50，51100的和,在进行汇总统计

Future接口的使用

package Thread3;

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

//需求：使用两个线程，并发计算1~50，51~100的和,在进行汇总统计
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //2提交任务
        Future<Integer>future1=es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1;i <= 50;i++){
                    sum+=i;
                }
                System.out.println("1-50计算完毕");
                return sum;
            }
        });
        Future<Integer>future2=es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 51; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("51-100计算完毕");
                return sum;
            }
        });
        //3获取结果
        int sum = future1.get()+future2.get();
        System.out.println("结果是："+sum);
        //4关闭线程池
        es.shutdown();
    }
}

Future接口

表示ExecutorService.submit()所返回的状态结果，就是call()的返回值

方法: V get()以阻塞形式等待Future中的异步处理结果(call()的返回值)

思考:什么是异步?什么是同步?

线程的同步

同步:

异步：

Lock接口

JDK5加入，与synchronized比较，显示定义，结构更灵活。

提供更多实用性方法,功能更强大、性能更优越。

常用方法:

void lock() //获取锁，如锁被占用，则等待。

boolean tryLock()//尝试获取锁（成功返回true。失败返回false，不阻塞)

void unlock()//释放锁

重入锁

package Thread3;
//ReentrantLock的使用

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyList {
    private Lock lock = new ReentrantLock();
    private String[] str = {"A","B","","",""};
    private int count = 2;

    public void add (String value){//传参，传入value
        lock.lock();
        try {
            str[count] = value;//count为下标2,传入value
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            System.out.println(Thread.currentThread().getName()+"添加了"+value);
        }finally{
            lock.unlock();
        }
    }
    public String[] getStr(){
        return str;
    }
}

package Thread3;

import java.util.Arrays;

public class TestMyList {
    public static void main(String[] args) throws Exception{
        MyList list = new MyList();
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                list.add("hello");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                list.add("world");
            }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Arrays.toString(list.getStr()));
    }
}

卖票

package Thread3;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable{
    private int ticket = 10000;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            lock.lock();
            try{
                 if(ticket<=0){
                     break;
                 }
                System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                 ticket--;
            }finally{
                lock.unlock();
            }
        }
    }
}

package Thread3;

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

public class TestTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        ExecutorService es = Executors.newFixedThreadPool(4);
        for (int i = 0; i<4;i++){
            es.submit(ticket);
        }
        es.shutdown();
    }
}

读写锁

ReentrantReadWriteLock:

一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。。支持多次分配读锁，使

多个读操作可以并发执行。

互斥规则:

写-写:互斥，阻塞。

读-写:互斥，读阻塞写、写阻塞读。

读-读:不互斥、不阻塞。

在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。

读写锁使用

package Thread3;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

public class ReadWriteDemo {
    //创建读写锁
    private ReentrantReadWriteLock rr1 = new ReentrantReadWriteLock();
    //读取读锁
    private ReadLock readLock = rr1.readLock();
    //获取写锁
    private ReadLock writeLock = rr1.readLock();
    private String value;
    //写入
    public void setValue(String value){
        writeLock.lock();
        try{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("写入："+value);
            this.value = value;
        }finally{
            writeLock.unlock();
        }
    }
    //读取
    public String getValue(){
        //使用读锁上锁
        readLock.lock();
        try{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("读取："+this.value);
            return this.value;
        }finally{
            readLock.unlock();
        }
    }

}

package Thread3;

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

public class TestReadWriteLock {
    public static void main(String[] args) {
        ReadWriteDemo readWriteDemo = new ReadWriteDemo();
        //创建线程池
        ExecutorService es = Executors.newFixedThreadPool(20);
        Runnable write = new Runnable() {
            @Override
            public void run() {
                readWriteDemo.setValue("张三："+new Random().nextInt(100));
            }
        };
        Runnable read = new Runnable() {
            @Override
            public void run() {
                readWriteDemo.getValue();
            }
        };

        long start = System.currentTimeMillis();
        for (int i = 0;i < 18;i++){
            es.submit(read);
        }
        //分配两个写的任务
        for (int i = 0; i<2;i++){
            es.submit(write);
        }
        es.shutdown();
        while(!es.isTerminated()){
            //空转
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
    }
}

常见线程安全集合

问题演示并用Collections方法解决

Collections工具类中提供了多个可以获得线程安全集合的方法。

public static Collection synchronizedCollection(Collection c).

public static List synchronizedList(List list)

public static Set synchronizedSet(Set s)

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

public static SortedSet synchronizedSortedSet(SortedSet s)

public static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K,V> m)

JDK1.2提供，接口统一、维护性高，但性能没有提升，均以synchonized实现。

问题：

Exception in thread “Thread-6” Exception in thread “Thread-3” java.util.ConcurrentModificationException

package T3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Demo01 {
    public static void main(String[] args) {
        //1创建arrylist
        //ArrayList<String> arrayList = new ArrayList<>();
        //1.1使用Collevtions中的线程安全方法转成线程安全集合
        //List<String> synList = Collections.synchronizedList(arrayList);
        //1.2使用CopyOnWriteArrayList
        CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
        //2创建线程
        for (int i = 0; i< 20 ; i++){
            int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0;j<10;j++){
                        arrayList.add(Thread.currentThread().getName()+"==="+temp+"==="+j);
                        System.out.println(arrayList.toString());
                    }
                }
            }).start();
        }
    }
}

CopyOnWriteArrayList

线程安全的ArrayList，加强版的读写分离。

写有锁，读无锁，读写之间不阻塞，优于读写锁。

写入时，先copy一个容器副本、再添加新元素，最后替换引用使用方式与ArrayList无异。

package T3;
//使用多线程操作CopyOnWriteArrayList

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

public class Demo02 {
    public static void main(String[] args) {
        //1创建集合
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        //2使用多线程集合
        ExecutorService es = Executors.newFixedThreadPool(5);
        //3提交任务
        for (int i = 0;i<5;i++){
            es.submit(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0;j<10;j++){
                        list.add(Thread.currentThread().getName()+"..."+new Random().nextInt(1000));
                    }
                }
            });
        }
        //4关闭线程池
        es.shutdown();
        while(!es.isTerminated()){}
        //打印结果
        System.out.println("元素个数："+list.size());
        for (String string : list){
            System.out.println(string);
        }
    }
}

CopyOnWriteArraySet

线程安全的Set，底层使用CopyOnWriteArrayList实现。

唯一不同在于，使用addIfAbsent()添加元素，会遍历数组，

如存在元素，则不添加（扔掉副本）。

package T3;


import java.util.concurrent.CopyOnWriteArraySet;

public class Demo03 {
    public static void main(String[] args) {
        //1创建集合
        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();//有序
        //2添加元素
        set.add("pingguo");
        set.add("huawei");
        set.add("xiaomi");
        set.add("lianxiang");
        set.add("pingguo");
        //3打印
        System.out.println("元素个数："+set.size());
        System.out.println(set.toString());
    }
}

Queue接口(队列)

Collection的子接口，表示队列FIFO(First In First Out)先进先出

常用方法：

抛出异常：

boolean add(E e)//顺序添加一个元素（到达上限后，再添加则会抛出异常)

E removeK)//获得第一个元素并移除（如果队列没有元素时，则抛异常)

Eelement()//获得第一个元素但不移除（如果队列没有元素时，则抛异常)

返回特殊值：推荐使用

boolean offer(E e)//顺序添加一个元素（到达上限后，再添加则会返回false)

E poll()//获得第一个元素并移除（如果队列没有元素时，则返回null)

E peek()//获得第一个元素但不移除（如果队列没有元素时，则返回null)

package T3;

import java.util.LinkedList;
import java.util.Queue;

public class Demo04 {
    public static void main(String[] args) {
        //1创建队列
        Queue<String> queue = new LinkedList<>();//(线程不安全)
        //2入队
        queue.offer("苹果");
        queue.offer("橘子");
        queue.offer("葡萄");
        queue.offer("西瓜");
        queue.offer("榴莲");
        //3出队
        System.out.println(queue.peek());
        System.out.println("===========");
        int size = queue.size();
        for (int i =0;i<size;i++){
            System.out.println(queue.poll());
        }
        System.out.println("出队完毕："+queue.size());

    }
}

ConcurrentLinkedQueue

线程安全、可高效读写的队列，高并发下性能最好的队列。

无锁、CAS比较交换算法，修改的方法包含三个核心参数(V,E,N)

V:要更新的变量、E:预期值、N:新值。

只有当V==E时，V=N;否则表示已被更新过，则取消当前操作。

package T3;

import java.util.concurrent.ConcurrentLinkedQueue;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1创建安全队列
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        //2入队操作
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 1;i<=5;i++){
                    queue.offer(i);
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 6;i<=10;i++){
                    queue.offer(i);
                }
            }
        });
        //3启动线程
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println("=====出队=====");

        //4出队操作
        int size = queue.size();
        for (int i = 0;i<size;i++){
            System.out.println(queue.poll());
        }

    }
}

BlockingQueue接口(阻塞队列)

Queue的子接口，阻塞的队列

Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的方法。

方法:
void put(E e)//将指定元素插入此队列中，如果没有可用空间，则等待。

E take()//获取并移除此队列头部元素，如果没有可用元素，则等待。

可用于解决生产生、消费者问题。

实现类：

ArrayBlockingQueue:
数组结构实现，有界队列。(手工固定上限)

LinkedB1ockingQueue:
链表结构实现，有界队列。（默认上限Integer.MAX_VALUE)

BlockingQueue的使用

package T3;

import java.util.concurrent.ArrayBlockingQueue;

public class Demo06 {
    public static void main(String[] args) throws Exception{
        //创建一个有界数列，添加数据
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
        //添加元素
        queue.put("aaa");
        queue.put("bbb");
        queue.put("ccc");
        queue.put("ddd");
        queue.put("eee");
        //删除元素
        queue.take();
        System.out.println("已经添加5个元素");
        queue.put("xyz");
        System.out.println("已经添加了6个元素");
        System.out.println(queue.toString());
        

    }
}

生产者消费者案例

package T3;

import java.util.concurrent.ArrayBlockingQueue;

public class Demo07 {
    public static void main(String[] args) {
        //1创建队列
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(6);
        //2创建两个线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<30;i++){
                    try {
                        queue.put(i);
                        System.out.println(Thread.currentThread().getName()+"生产了"+i+"号面包");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        },"晨晨");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<30;i++){
                    try {
                        Integer num = queue.take();
                        System.out.println(Thread.currentThread().getName()+"消费了"+i+"号面包");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"冰冰");
        //启动线程
        t1.start();
        t2.start();
    }
}

ConcurrentHashMap

初始容量默认为16段(Segment），使用分段锁设计。

不对整个Map加锁,而是为每个Segment加锁。

当多个对象存入同一个Segment时，才需要互斥。

最理想状态为16个对象分别存入16个Segment，并行数量16使用方式与HashMap无异。

ConcurrentHashMap的使用

package T3;

import java.util.concurrent.ConcurrentHashMap;

public class Demo08 {
    public static void main(String[] args) {
        //1创建集合
        ConcurrentHashMap<String,String> hashMap = new ConcurrentHashMap<String,String>();
        //2使用多线程添加数据
        for (int i=0;i<5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int k = 0;k<10;k++){
                        hashMap.put(Thread.currentThread().getName()+"--"+k,k+"");
                        System.out.println(hashMap);
                    }
                }
            }).start();
        }
    }
}