Java多线程总结

最新推荐文章于 2024-09-03 09:19:35 发布

Monkey__z

最新推荐文章于 2024-09-03 09:19:35 发布

阅读量390

点赞数

分类专栏： Java基础文章标签： java 多线程线程安全

本文链接：https://blog.csdn.net/m0_37241851/article/details/70096841

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

最近把Java的多线程、锁和线程安全类又学了一遍，感觉很多问题理解比以前全面也透彻很多，借鉴不少其他博客和《Java核心技术卷一》，本文的主要内容可以先点开上面的目录浏览一下

一多线程的启动

1.1 创建线程

创建线程类实现Runnable接口，及run( )方法
创建线程类继承Thread类，并重写run( )方法
创建线程类的对象，调用start( ) 方法，启动这个线程对象

1.2 线程优先级：

优先级分为1~10，十个优先级
一个线程继承它的父线程优先级。
通过setpPriority(int n)设置优先级

1.3 守护线程：

也叫作后台进程，不需要手动停止后台进程，因为前台进程全部死亡后，后台进程自动进入死亡状态
唯一用途：用于给其他线程提供服务，例如JVM的垃圾回收进程，计时器

1.4 线程安全：

经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。

二线程状态的转换

2.1 线程的状态

在java.lang.Thread类中定义一个内部枚举类State，这个枚举类中一共定义了线程类的六种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED;
这里写图片描述
- 新建状态New
当线程对象被创建后就进入新建状态，例：Thread t = new MyThread( );
- 就绪状态 Runnable
当线程对象调用start( )方法后，线程对象进入就绪状态
- 运行状态 Running
进程获得CPU资源开始运行
- 阻塞状态 Blocked
阻塞状态分为三种：
- 等待阻塞 wait blocked：
运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
- 同步阻塞 synchronized blocked：
线程在获取一个内部的对象锁时失败，进入同步阻塞状态；当其他线程释放该锁后，线程调度器允许本线程持有该锁，从而变成非阻塞状态
- 其他阻塞blocked：
通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

2.2 状态间转换

New —> Runnable : 调用线程对象的start( )方法
Runnable —> Run ：线程获得CPU资源
Run —> 同步阻塞：视图获取一个内部的锁对象时失败
同步阻塞 —> Runnable：其他线程释放锁，线程控制器将同步阻塞变为非阻塞
Run —> 等待阻塞：调用wait( )方法：Object.wait( )、Condition.await( )；
等待阻塞 —> Run：其他线程调用sign( )方法将等待阻塞状态变为非阻塞态：Object.notify( )、Object.notifyAll( )、 Condition.notify( )、 Condition.notifyAll( )
Run —> 其他阻塞：调用线程的Thread.sleep( )或Thread.join( )或发出了I/O请求时

三锁对象

锁对象的实现分为两种：java.util.concurrent框架的ReentrantLock 和 synchronized 关键字

3.1 ReentrantLock锁对象

使用：

ReentrantLock  mylock  =  new   ReentrantLock( );
mylock.lock( );  // 获取锁
try {
     xxxx
}
finally {
     mylock.unlock( );  //释放锁
}

获取锁和释放锁中间的部分称为临界区，释放锁语句必须放在finally子句中，防止犹如异常导致锁始终无法释放。

3.2 条件对象

Condition是一个接口，在类中声明这样的接口引用变量，通过锁对象的newCondition（）方法获得条件对象实例。
使用条件对象的await( )、signalAll( )、signal( )方法阻塞和解除线程阻塞。

class  LockTest {
     private  Condition  myCondition;
     private  Lock  myLock;

     public  void  test( ) {
               myLock = new ReentrantLock( );
               myCondition = myLock.newCondition( );
               while( xxx ) {
                    myCondition.await( );
               }
}

3.3 synchronized关键字

使用synchronized必须要理解到，每个对象有一个内部锁，并且该锁有一个内部条件。

synchronized有两种用法：
- 用在方法名前面：将整个方法名作为临界区
- 同步阻塞：获得这个对象的同步锁

(1) 用在方法名前：
并直接使用wait( )、signal( )、signalAll( )方法，这些方法是继承于Object类的。
public synchronized void test( ) {
xxx
}

(2) 同步阻塞：
synchronized (obj) {
xxx
}

通过上面的方式获得obj对象的同步锁，当此时其他线程访问这个对象时就会发生同步阻塞。

四阻塞队列

4.1 阻塞队列类

阻塞队列BlockingQueue是一个接口，他有两个实现类
BlockingQueue
- ArrayBlockingQueue
- LinkedBlockingQueue
这里写图片描述

这里写图片描述
阻塞队列方法分为如下三类，这取决于当队列满或空时他们的相应方式。如果将队列当做线程管理工具来使用，将要用到put和take方法。当试图香漫的队列中添加或者从空的队列中移除元素时，add、remove和element操作抛出异常。当然，在一个对县城程序中，队列会在任何时候空或满，因此，一定要使用offer、poll和peek方法作为替代。这些方法如果不能完成任务，只是给出一个错误提示而不会抛出异常。

抛异常：
- add( )
- element( )
- remove( )

返回null/false：
- offer( )
- peek( )
- poll( )

阻塞：
- put( )
- take( )

下面是两个例子，可以通过比较体会到阻塞队列的好处。
例子一：经典的生产者-消费者模式，通过阻塞队列和Object.wait()和Object.notify()实现，wait()和notify()主要用来实现线程间通信。
例子二：使用阻塞队列实现的生产者-消费者模式。


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

/**
 * Created by Zcl on 2017/4/11.
 * 例子一
 */
public class Test {
    private int queueSize = 10;
    private Queue<Integer> queue = new LinkedList<>();

    public static void main(String[] args) {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();

        producer.start();
        consumer.start();
    }

    class Consumer extends Thread{
        @Override
        public void run() {
            System.out.println("启动消费者线程");
            consume();
        }

        private void consume() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == 0){
                        try {
                            System.out.println("队列空，等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.poll();     //每次移走队首元素
                    queue.notify();
                    System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                }
            }
        }
    }

    class Producer extends Thread{
        @Override
        public void run() {
            System.out.println("启动生产者线程");
            produce();
        }

        private void produce() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("队列满，等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.offer(1);    //每次插入一个元素
                    queue.notify();
                    System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                }
            }
        }
    }
}

例子二：

import java.util.concurrent.ArrayBlockingQueue;

/**
 * Created by Zcl on 2017/4/11.
 * 例子二
 */
public class Test2 {
        private int queueSize = 10;
        private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(queueSize);

        public static void main(String[] args) {
            Test2 test = new Test2();
            Producer producer = test.new Producer();
            Consumer consumer = test.new Consumer();

            producer.start();
            consumer.start();
        }

        class Consumer extends Thread{

            @Override
            public void run() {
                consume();
            }

            private void consume() {
                while(true){
                    try {
                        queue.take();
                        System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        class Producer extends Thread{

            @Override
            public void run() {
                produce();
            }

            private void produce() {
                while(true){
                    try {
                        queue.put(1);
                        System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
}

五线程安全类

5.1 常用线程安全类

HashTable 是线程安全类
StringBuffer 是线程安全的
Vector是线程安全的类

我们常用的线程安全类就是以上三个，他们在多线程使用场景中，能够保证线程安全，同时牺牲了速度作为代价

5.2 concurrent包中集合类

java.util.concurrent包提供了映射表、有序集和队列的高效实现。

ConcurrentHashMap
ConcurrentSkipListMap
ConcurrentSkipListSet
ConcurrentLinkedQueue

与大多数集和不同，size( )是通过遍历整个集和得到的

可能你会想，既然都已经有线程安全的HashTble了，为什么还要再弄一个ConcurrentHashMap，后面我们仔细分析。

六相关接口、类整理

Runnable 接口
- void run( )
必须实现这个方法，将线程要执行的代码放到run( )中

Thread类
实现了Runnale接口
- Thread(Runnable target)
构造一个新进程，用于调用给定target的run()方法
- void start（）
启动这个进程，将引发调用run（）方法
- void interrupt()
中断当前进程
- boolean isInterrupted( )
判断当前进程是否被中断
- static boolean Interrupted( )
判断当前进程是否被中断，并将中断状态重置为false
- static Thread currentThread（）
返回当前执行进程的进程对象
- Thread.State getState( )
返回当前这一线程的状态
- void setPriority( )
设置当前进程的优先级
- public static yield()
将当前进程从运行态变成就绪态

Lock接口
- lock( )
获得这个锁
- unlock（）
释放这个锁，一定要在finally中进行这个方法，不然发生异常时这个锁就一直释放不了了
- Condition newConditon( )
返回一个跟该锁相关的条件对象

ReentrantLock类
- ReentrantLock（）
构造函数

ReentrantReadWriteLock类
ReentrantLock类中有两个内部类：ReadLock( ) 和 WriteLock( )
这两个类的对象通过，ReentrantLock类中的以下方法获得：
- readLock( )
- writeLock( )

Condition接口
- void await（）
将该线程放到条件的等待集中
- void signalAll( )
解除该条件的等待集中的所有线程的阻塞状态
- void signal（）
随机解除一个该条件等待集中某个线程的阻塞状态

Object类
- void wait( )
- void signal( )
- void signalAll( )

BlockingQueue接口
他有两个主要的实现类：ArrayBlockingQueue和LinkedBlockingQueue
抛异常：
- add( )
- element( )
- remove( )
返回null/false：
- offer( )
- peek( )
- poll( )
阻塞：
- put( )
- take( )

http://www.cnblogs.com/lwbqqyumidi/p/3804883.html
http://www.cnblogs.com/wxd0108/p/5479442.html
http://blog.csdn.net/paincupid/article/details/51793621