线程基础知识

前言:复习了一遍线程,查漏补缺,但又经常记不住,只好写下来,时不时回来看看,可能会有错误。。。。我能力有限。。。阅读大约需要一刻多

目录:
1、线程的创建
2、对象及变量的并发访问
3、线程间通信
4、Lock
5、线程池
6、Fork/Join框架
7、定时器Timer

java线程基础

线程有六种状态:New(新建)、Runnable(可运行)、Blocked(被阻塞)、Waiting(等待)、Timed waiting(计时等待)、Terminated(被终止),有两种创建方法,继承Thread或者实现Runnable接口,由于Java是单继承,所以继承Thread的话,在设计上有局限性,不支持多继承,Thread.java类也是实现了Runnable接口,这意味着Thread(Rnnable r)不仅可以传一个Runnable接口的对象,还可以传Thread类的对象。

Thread(Runnable target):构造一个新线程,用于调用给定目标的run()方法
新建:继承Thread:
MyThread thread=new MyThread();
实现Runnable:

MyRunnable runnable=new MyRunnable();
        Thread thread=new Thread(runnable);

从类Thread继承或者实现Runnable接口的创建的线程,方法run是没有返回值的,带返回值的线程通过Callable来定义,并通过接口Future来获得线程的返回值。
接口Callable的定义如下:

public interface Callable {
    V call() throws Exception;
}

使用Callable创建的线程须实现call方法,call方法的返回值是由V指定的。
接口Future允许在某个时间获得线程运行的结果,它保存了使用Callable接口定义的线程异步运行的结果。FutureTask包装器同时实现了Runnable和Callable接口,可以把Callable对象进行封装并转换为Future对象,构造方法如下:

FutureTask(Callable task)
    FutureTask(Runnable runnable,V result)

通过V get()获得线程的返回值,cancel()尝试取消任务的运行,使用如下:

Callable<V> caller=xxxx;
    FutureTask<V> task=new FutureTask<V> (caller);
    Thread t=new Thread(task);
    t.start();
    V result=task.get();
currentThread():返回代表当前线程的Thread对象
isAlive():判断当前的线程是否处于活动状态,即已经启动且尚未终止
sleep(long mills):休眠给定的毫秒数,sleep方法可能抛出InterruptedException异常


voiod start():启动这个线程,将引发调用run方法。这个方法将立即返回,并且新线程将并发执行
void run():调用关联Runnable的run()方法

void interrupt():向线程发送中断请求,线程的中断状态设为true,仅仅实在当前线程中打了个停止的标志,不是真的停止了线程
static boolean interrupted():测试当前线程是否被中断,这是一个静态方法会有副作用,第二次调用将当前线程的中断状态重置为false,即清楚状态标志位

boolean isInterrupted():测试线程是否被终止,不改变线程的中断状态,不清除状态标志
终止正在运行的线程有三种方法:
(1)使用退出标志,使线程正常退出,也就是当run方法执行完后退出;
(2)使用stop方法,已过时;
(3)使用interrupt方法中断进程。

异常法:
沉睡停止法:如果在sleep状态下停止某一线程,会进入catch语句,并且清除状态值,使之变为false
return法:将方法interrupt和return连用实现停止线程的目的

//void joid():等待终止指定的线程
void join():等待指定的线程死亡或经过指定的毫秒数
getState():得到这一线程的状态:new/Runnable/Waiting/Timed_Waiting/Terminated
void stop():停止该线程,此方法已过时
void suspend():暂停这一线程的执行,已过时
void resume():恢复线程,仅在调用suspend()之后调用,已过时

每一个线程都有一个默认的继承父线程的优先级,MIN_PRIORITY(1)与MAX_PRIORITY(10)之间,NORM_PRIORITY优先级为5,优先级高只是被调度的机会大,不是一定比低优先级的先调度

void setPriority()//设置线程的优先级,优先级必须在MIN_PRIORITY(1)与MAX_PRIORITY(10)之间,一般使用NORM_PRIORITY优先级为5
static int MIN_PRIORITY//线程的最小优先级为1
static int NORM_PRIORITY//线程的默认优先级5
static int MAX_PRIORITY//线程的最高优先级10

satic void yield():导致当前执行线程处于让步状态,放弃当前的CPU资源,将它让给其他的任务去占用CPU执行时间。如果有其他的可运行线程具有至少与此线程同样高的优先级,那么这些线程接下来会被调度,ATTENTION!这是一个静态方法

void setDaemon(boolean isDaemon):标识该线程为守护线程或用户线程,这一方法须在线程启动之前调用,当进程中不存在非守护线程时,守护线程将自动销毁,例如垃圾回收线程,任何一个守护线程都是JVM中所有非守护线程的保姆。

对象及变量的并发访问

如果多个线程共同访问1个对象中的实例变量,有可能出现非线程安全问题。使用带synchronized关键字的方法,哪个线程就持有该方法所属对象的锁lock,其他线程只能等待。只有共享资源的读写访问才需要同步化,如果多个线程访问多个对象,则JVM会创建多个锁。
如果线程A先持有object对象的Lock锁,B线程可以以异步的方式调用object对象的非synchronized类型的方法;如果线程A先持有,B线程这时候调用object对象中的synchronized类型的方法时则需要等待,也就是同步。

通过在run方法前加synchronized关键字,使多个线程在执行run方法时,以排队的方式进行处理。当一个线程调用run前,先判断run方法有没有上锁,如果上锁则等待其他线程执行完再调用。synchronized可以在任意对象及方法上加锁,这段区域称为互斥区或临界区。

synchronized:自动提供一个锁及相关的“条件”,同步不具有继承性,synchronized方法是对当前对象加锁,而synchronized代码块是对某一个对象加锁
volatile关键字:使变量在多个线程中可见,强制从公共堆栈中取得变量的值,而不是从线程私有堆栈中,但不支持原子性!

synchronized与volatile比较:
修饰范围 多线程是否阻塞 数据可见性和原子性
synchronized 方法以及代码块 会出现 都有
volatile 变量 不会 可见但不原子

将静态方法声明为synchronized也是合法的,调用该方法获得相关的类对象的内部锁,没有其他线程可以调用同一个类的这个或任何其他的同步静态方法,内部锁和条件存在一些局限:
(1)不能中断一个正在试图获取锁的线程
(2)试图获得锁时不能设定超时
(3)每个锁仅有单一的条件,可能是不够的
(4)最好既不使用Lock/Condition也不使用synchronized关键字,可以考虑使用阻塞队列或者并行流
(5)如果synchronized适合就用,减少编写的代码数量
(6)如果特别需要Lock/Condition结构提供的独有特性才使用

同步块的内置监视器使用:

public class T{
    synchronized (this){
        //使用默认的当前对象this
    }
    private Object object;
    public void test(){
        synchronized (object){
            //使用当前类的属性
        }
    }
    public void test(Object object){
        synchronized (object){
            //使用本地变量或方法的形式化参数
        }
    }
    public Object object;
    public class Test{
        private T t;
        public void test(){
            synchronized (t.object){
                //使用其他类的属性
            }
        }
    }
    synchronized (A){
        synchronized (B){
            //嵌套的同步块
        }
    }
    public static void test(){
        synchronized (T.class){
            //静态类的对象
        }
    }
}

线程间通信

等待/通知机制(wait/notify):
void wait():导致线程进入等待状态直到它被通知,Object类方法,将当前线程置入“预执行队列”,并在wait所在代码行停止执行,直到接到通知或被中断为止,该方法只能在一个同步方法中调用,调用前须取得对象的对象级别的锁,若没有就抛异常,执行后,当前线程释放锁,然后从运行状态退出,进入等待队列直到被唤醒

void wait(long mills)
void wait(long mills,inr nanos)

void notify():如果多个线程等待则随机选择一个在该对象上调用wait()方法的线程,解除其阻塞状态,该方法只能在一个同步方法或同步块中调用,也要在同步方法或块中调用。执行完后当前线程不会马上释放对象锁,wait状态的线程也不能马上获取该对象锁,要等到退出synchronized代码块后,当前线程才会释放锁

void notifyAll():解除那些在该对象调用wait方法的线程的阻塞状态,使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出进入可运行状态。该方法只能在同步方法或者同步块内部调用,如果当前线程不是对象锁的持有者,该方法抛出IllegalMonitorStateException异常

生产者/消费者模型:

void join():等待指定的线程死亡或经过指定的毫秒数后,具有使线程排队运行的作用,但与synchronized不同,join在内部使用wait方法进行等待,synchronized使用的是对象监视器原理
join(long)的功能是在内部使用wait(long)方法进行等待,会释放锁,而sleep(long)不释放锁

类ThreadLocal的使用,可以使每个线程绑定自己私有变量

Lock

可重入锁是一种无阻塞的同步机制,class ReentrantLock extends Object implements Lock,Serializable,这是一种互斥锁,增加了如获取锁时公平性设置、测试锁trylock、测试锁是否正在被持有等功能,锁分为公平锁和非公平锁,公平锁表示线程获取锁的顺序按照线程加锁的顺序来分配,即先来先分;非公平锁是一种获取锁的抢占机制,随机获得锁
。Condition对象与ReentrantLock结合可以实现等待/通知,“选择性通知”。
构造方法如下:

ReentrantLock();
//fair默认为false
ReentrantLock(boolean fair)

使用可重入锁在进行同步控制时,需要明确地定义可重入的锁对象,并在该对象上进行加锁和解锁操作,通常放进try{}catch(){}finally{}语句块中,用ReentrantLock类保护代码块,确保任何时刻都只有一线程进入临界区,一旦一个线程封锁了锁对象,其他任何线程都无法通过lock()语句,把解锁操作括在finally子句,不要因为异常的抛出而跳出临界区,如果在结束之前抛出了异常,finally子句将释放锁,但会使对象可能处于一种受损状态。

Lock lock = new ReentrantLock();
lock.lock();
try{
    //
}catch (Exception e){
   //
}finally {
    lock.unlock();
}

ReentrantReadWriteLock读写锁维护了一对相互关联的读锁和写锁,在没有线程持有写锁的情况下,读锁可以有多个线程同时持有,写锁只能由一个线程持有,具有 锁的获取属性、可重入性、锁降级、获取时中断、条件操作、监视状态等属性。

ReentrantReadWriteLock reentrantReadWriteLock=new ReentrantReadWriteLock();
Lock readLock=reentrantReadWriteLock.readLock();
Lock writeLock=reentrantReadWriteLock.writeLock();
readLock.lock();
try{
    //
}catch (Exception e){
    //
}finally {
    readLock.unlock();
}

writeLock.lock();
try{
    //
}catch (Exception e){
    //
}finally {
    writeLock.lock();
}

synchronized同步锁是一种互斥锁,形式简单易于使用,但依赖于不直观的对象后的内置监视器;
可重入锁是一种互斥锁,在同步锁的基础上拓展了很多功能,如非阻塞枷锁操作、尝试获取锁时可以中断、测试锁等;
读写锁除了可重入锁的特性外,把锁分为读锁和写锁,多个线程可以同时获取读锁,还可以锁降级把写锁降为读锁,提供了更高程度的并发

void lock()//获取这个锁,如果锁同时被另一个线程拥有则发生阻塞
void unlock()//释放这个锁
int getHold()//查询当前线程保持此锁定的个数,即调用lock()的次数
int getQueueLengh()//返回正在等待获取此锁定的线程的估计数
boolean hasQueuedThread(Thread thread)//查询指定线程是否正在等待获取此锁定
boolean hasQueuedThreads()//查询是否有线程正在等待获取此锁定
boolean hasWaiters(Condition c)//查询是否有线程正在等待与此锁定有关的condition条件
boolean isFair()//判断是不是公平锁
boolean isHeldByCurrentThread()//查询当前线程是否保持此锁定
boolean isLocked()//此锁定是否由任意线程保持
void lockInterruptibly()//如果当前线程未被中断,则获取锁定,否则出现异常
boolean tryLock()//仅在调用时锁定未被另一个线程保持的情况下,才获取锁定

ReentrantLock()//构建一个可以被用来保护临界区的可重入锁
ReentrantLock(boolean fair)//创建一个带有公平策略的锁,一个公平锁偏爱等待时间最长的线程,但是这公平的保证将大大降低性能,所以,默认锁没有被强制为公平的

Condition newCondition()//返回一个与该锁相关的条件对象
void await()//将该线程放到条件的等待集中
void signalAll()//接触该条件的等待集中的所有线程的阻塞状态
void signal()//从该条件的等待集中随机选取一个线程,解除其阻塞状态

void notifyAll():解除那些在该对象调用wait方法的线程的阻塞状态。该方法只能在同步方法或者同步块内部调用,如果当前线程不是对象锁的持有者,该方法抛出IllegalMonitorStateException异常
void notify():随机选择一个在该对象上调用wait()方法的线程,解除其阻塞状态,该方法只能在一个同步方法或同步块中调用
void wait():导致线程进入等待状态直到它被通知,该方法只能在一个同步方法中调用

void wait(long mills)
void wait(long mills,inr nanos)

线程池

线程池包含了若干个准备运行的空闲线程,县城在程序运行的开始创建,可以把创建的Runnable对象交给线程池中的线程来运行,运行后,如果没有其他任务,线程转入休眠状态,等有任务再被唤醒,直到所有任务都执行结束再关闭线程池。
线程池机制分离了任务的创建和执行,使用线程池执行器,仅需要实现Runnable对象并交其给执行器,执行器会使用线程池的线程执行,起到了维护和管理线程的作用。
接口Executor的对象可以接受提交到线程池的Runnable任务,其中的execute方法异步地执行给定的Runnable对象
Executor executor=new Executor() {
    @Override
    public void execute(Runnable command) {
        //
    }
};

或者

public class T implements Executor{
    @Override
    public void execute(Runnable command) {
     //
    }
}

接口ExecutorService从父接口Executor继承,提供了关闭线程池的方法shutdown。

类ThreadPoolExecutor可以用来创建一个线程池,构造方法有四个,有七个参数,

public ThreadPoolExecutor(int corePoolSize,//线程池的线程数
                          int maximumPoolSize,//允许的最大线程数
                          long keepAliveTime,//线程数超过处理核数时多余的空闲线程等待新任务的最大等待时间
                          TimeUnit unit,//上一个参数的等待时间
                          BlockingQueue workQueue,//任务队列,调用执行方法提交的Runnable任务队列
                          ThreadFactory threadFactory,//创建新线程时所用的工厂
                          RejectedExecutionHandler handler//超出线程队列容量时执行的处理程序) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

类Executors提供了线程池创建的工厂方法,静态的可以直接调用:
newFixedThreadPool:创建固定大小的线程
newSingleThread:创建只有一个线程的线程池
newCachedThreadPool:创建一个线程池,需要时创建新线程,会重复利用旧线程
newSingleThreadScheduledExecutor:创建一个线程的线程池,可以在指定时间间隔或周期性地执行
newScheduledThreadPool:创建一个线程池,可以在指定的时间间隔或周期性执行

ExecutorService executorService=Executors.newSingleThreadExecutor();
 ThreadPoolExecutor threadPoolExecutor= (ThreadPoolExecutor) Executors.newCachedThreadPool();
                Fork/Join框架

主要由Fork和Join两个操作构成,Fork操作主要用于对任务和数据的划分,Join操作主要用于对各部分结果的合并。感觉类似于Hadoop中的Map/Reduce思想,都是先把任务划分,然后对结果进行合并。Fork/Join框架实现了任务定义和任务处理功能的分离,实现了ExecutorService接口,会自动地将任务分配给线程池的线程,并负责线程管理等。

工作窃取算法:框架采用双端队列,即支持先进先出FIFO和后进先出LIFO,进入队列就push,出队列就pop,窃取任务就take,当某个工作线程执行完自己的任务后,它“很热心”,想帮助别人,但有不好意思从队列的开头拿出任务执行,就从队列的尾端拿出任务执行,主要由ForkJoinPool和ForkJoinTask类完成。

类ForkJoinPool是执行的入口,实现了ExecutorService类,负责管理线程,与其他ExecutorService的区别就是实现了工作窃取算法

@sun.misc.Contended
public class ForkJoinPool extends AbstractExecutorService

创建如下:

ForkJoinPool forkJoinPool=new ForkJoinPool();
ForkJoinPool forkJoinPool1=new ForkJoinPool(10);

有两种使用方法,一是通过invoke、execute、submit在外部对Fork/Join操作调用,二是在框架内调用fork或者invoke等

类ForkJoinTask是执行的任务的基类,实现了Future接口,提供了一系列机制来实现操作,有两个子类,

RecursiveAction recursiveAction=new RecursiveAction() {
    @Override
    protected void compute() {
    //无返回值
    }
};
RecursiveTask recursiveTask=new RecursiveTask() {
    @Override
    protected Object compute() {
        return null;//有返回值
    }
};

定时器Timer

Timer类主要负责计划任务的功能,也就是在指定时间开始执行某一任务,Timer类设置计划任务,但封装任务类却是TimeTask类,是一个抽象类,因此执行计划任务的代码要放入TimerTask的子类,以队列的方式一个一个顺序执行,所以执行时间有可能与预期的不同

schedule(TimerTask t,Date time):在指定的日期执行一次任务
schedule(TimerTask t,Date firsttime,long period):在指定的日期之后按指定的间隔周期,无限循环地执行某一任务
TimerTask的cancel():将自身从任务队列中进行清除
Timer的cancel():将任务队列的全部任务进行清空,但有时不一定会停止计划任务,任务仍正常执行
schedule(TimerTask t,long delyTime):以执行方法时的当前时间为参考时间,在此时间基础上延迟指定的毫秒数后执行一次TimerTask任务

阻塞队列

不要调用Thread类和Runnable对象的run()方法,直接调用run()只会执行同一个线程中的任务,而不会启动新线程,应该调用Thread.start()方法,这将创建一个执行run的新线程
被阻塞就无法检查中断状态,中断一个线程不过是引起它的注意,被中断的线程可以决定如何响应中断,如果在中断状态被置位时调用sleep方法,不会休眠,相反,它会消除这一状态并抛出异常
没有可以强制线程终止的方法。然而,interrupt方法可以用来请求终止线程,调用方法,线程的中断状态将被置位,每个线程都有一个boolean标志,调用静态的Thread.currentThread方法获得当前线程,然后调用isInterrupted方法

你可能感兴趣的:(java,线程)