JAVA多线程

多线程

一、线程的概念

线程，有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行

线程状态

• 新建(New)：新建了一个线程；
• 就绪(Runnable)：就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；
• 运行(Running)：运行状态是指线程占有处理机正在运行；
• 阻塞(Blocked)：阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行；
• 死亡(Dead):线程执行完毕或因异常结束。

---

阻塞的方式

• 线程调用Object.wait()或Thread.join()方法，或等待Lock或Condition时，该线程等待另一个线程的通知条件，进入等待状态；
• 运行的线程在获取一个内部对象锁时，若该同步锁被别的线程占用，该线程进入阻塞状态。当其他线程释放该锁，并且线程调度器允许本线程持有它的时候，该线程将变成非阻塞状态；
• Thread.sleep()、Object.wait()、Thread.join()、Lock.tryLock()以及Condition.await()的计时板，这些方法有一个超时参数，调用它们将导致线程进入计时等待状态，这一状态保持到计时期满或者收到适当的通知。

---

线程调度方式

• 抢占式调度：用于桌面及服务器操作系统，系统给每一个可运行线程一个时间片来执行任务，当时间片用完切换到另一个线程；
• 用于手机这样的小型设备，一个线程只有在调用yield方法或被阻塞或等待时，才失去控制权。

二、创建线程的三种方式

1.实现Runnable接口创建线程

/*第一种方式，实现Runnable接口*/
Runnable r = () -> {
    while (true) {
        try {
            System.out.print("*");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
    }
};

Thread t1 = new Thread(r);
t1.start();

2.继承Thread类创建线程

/*第二种方法，创建Thread子类对象*/
MyThread t2 = new MyThread();
t2.start();

/*MyThread类*/
class MyThread extends Thread{
    public void run(){
        while (true){
            try {
                System.out.print("=");
                Thread.sleep(1000);
            }catch (InterruptedException e){}
        }
    }
}

3.使用Callable和Future创建线程

/*第三种方法，使用Callable和Future创建线程*/
Callable<Character> callable = () -> {

    System.out.print("&");
    return '$';

};

FutureTask<Character> futureTask = new FutureTask<>(callable);
Thread t3=new Thread(futureTask);
t3.start();
try {
    System.out.print(futureTask.get());
}catch (Exception e){}

第三种与第一种类似，多了返回值；
第二种不推荐使用，应该将并行运行的任务与运行机制解耦合。

三、同步

竞争条件：若两个线程存取相同的对象，并且每一个线程都调用了修改该对象的方法，可能发生讹误，这种情况通常称为竞争条件。
防止代码受并发访问干扰的两种方式：synchronized关键字和锁对象。

加锁的方式：

myLock.lock();      //加锁
try{
    statement;
}
finally{
    mylock.unlock();      //在finally语句进行解锁操作，当抛出异常时锁被释放
}

设置超时参数：

if(myLock.tryLock(100,TimeUnit.MILLISECONDS)){
    try...
}else

一个线程封锁了锁对象，其他线程调用lock时，被阻塞，直到该线程释放锁对象。

条件对象(Condition)：

当线程运行条件不足时，调用Conditionde的await方法，该线程阻塞，并释放锁，使其它线程可以修改对象状态，当锁可用并且另一个线程调用signalAll方法时，解除阻塞。(signal方法随机解除某个线程的阻塞)

synchronized关键字：

• synchronized关键字用于保护整个方法，此时，相当于该方法调用了对象的内部锁；
• 只有一个相关条件,wait方法相当于Condition的await，notifyAll/notify方法等价于signalAll/signal方法。

volatile关键字：

• volatile为实例域的同步访问提供免锁机制 ;
• 若变量除了赋值之外无其他操作，可以声明为volatile。

关于锁的一些解析：
锁解析链接

四、线程安全的集合

较早的线程安全集合有Vector和Hashtable，现在这些类已经弃用了，取而代之的是ArrayList类和HashMap类，这些类是非线程安全的。但是，任何集合类都可以通过同步包装器变为线程安全的。

List<E> synchArrayList = Collections.synchronizedList(new ArrayList<E>());

java.util.concurrent包提供了map、list、set的高效实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet和ConcurrentLinkedQueue、CopyOnWriteArrayList和CopyOnWriteArraySet。

一些集合操作：

package thread;

import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author Zhang
 * @date 2018/8/1
 * @Description  线程安全集合
 */
public class SafeCollections {

    private static ConcurrentHashMap<String, Long> map = new ConcurrentHashMap<>();

    public static void main(String[] args) {

        /*map原子更新*/
        String word = "word";
        String word1 = "word1";
        String word2 = "word2";
        String word3 = "word3";
        String word4 = "word4";
        Long newValue ;
        Long oldValue ;
        map.put(word, (long) 1);
        do{
            oldValue = map.get(word);
            newValue = oldValue == null ? 1 : oldValue + 1;
        }while (! map.replace(word,oldValue,newValue));

        System.out.println(map);

        /*LongAdder方法*/
        ConcurrentMap<String, LongAdder> map1 = new ConcurrentHashMap<>();
        map1.putIfAbsent(word1,new LongAdder());
        map1.get(word1).increment();
        map1.get(word1).increment();

        System.out.println(map1);

        /*compute方法*/
        map.compute(word2,(k,v) -> v == null ? 1 : v+1);

        System.out.println(map);

        /*merge方法增加键值*/
        map.merge(word3,1L, (existingValue, otherValue) -> existingValue+otherValue);
        System.out.println(map);

        map.merge(word4, 1L, Long ::sum);
        System.out.println(map);

        /*批处理*/
        String result = map.search(1, (k,v) -> v > 1 ? k:null);
        System.out.println(result);

        map.forEach(1,(k,v) -> System.out.println(k+"->"+v));

        Long sum = map.reduceValues(1,Long::sum);
        System.out.println(sum);

        Set<String> words = map.keySet(1L);
        System.out.println(words);
    }
}

五、线程池

当程序中创建了大量的生命期很短的线程，应该使用线程池(thread pool)。一个线程池中包含许多准备运行的空闲线程。将Runnable对象交给线程池，就会有一个线程调用run方法，当run方法退出时，线程不会死亡，而是在池中准备为下一个请求提供服务。

创建线程池方法：

• newCachedThreadPool
• newFixedThreadPool
• newSingleThreadExecutor
• newScheduledThreadPool
• newSingleThreadScheduledExecutor

连接线程池的步骤：

• 调用执行器方法；
• 调用submit提交Runnable或Callable对象；
• 若要取消一个任务，或提交Callable对象，保存好返回的Future对象；
• 当不再提交任何任务时，调用shutdown。

简单的线程池操作：

package thread;

import java.util.concurrent.*;

/**
 * @author Zhang
 * @date 2018/8/1
 * @Description  线程池
 */
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(1000);
                return 1;
            }
        };
        for(int i = 0; i < 100 ; i++) {
            Future<Integer> result = pool.submit(callable);
        }
        pool.shutdown();
        System.out.println("最大数量为："+((ThreadPoolExecutor)pool).getLargestPoolSize());

    }
}

用于练习的一些相关代码连接：

代码链接