Object类相关api（相关的方法一定是当前线程在获取了对应的锁对象才能调用，否则会抛出异常）
- o.wait() ：锁对象调用该方法使当前线程进入等待状态，并立刻释放锁对象，直到被其他线程唤醒进入等锁池。
- o.wait(long) ：锁对象调用该方法使当前线程进入等待状态，同时释放锁对象。但是超过等待的时间后线程会自动唤醒，或者被其他线程唤醒，并进入等锁池中。
- o.wait(long,int) ：和o.wait(long)方法一样，如果int参数大于0则前面的long数字加1
- o.notify()：随机唤醒一个处于等待中的线程（同一个等待阻塞池中）
- o.notifyAll()：唤醒所有等待中的线程（同一个等待阻塞池中）
Thread类的相关api
- Thread.currentThread()：返回对当前线程对象的引用
- Thread.interrupted()：检测当前线程是否已经中断（调用该方法后后就将该线程的中断标志位设置位false，所以连续两次调用该方法第二次肯定时false）
- Thread.sleep(long millis)：使当前线程睡眠（不会释放锁对象，可以让其他线程有执行的机会）
- Thread.yield()：使当前线程放弃cpu的执行权（有可能立刻又被重新选中继续执行，只可能给优先级更高的线程机会）
- t.getId():返回该线程的id
- t.getName():返回该线程的名字
- t.getPriority():返回该线程的优先级
- t.getState():返回该线程的状态
- t.getThreadGroup()：返回该线程所属的线程组
- t.interrupt():将该线程中断（实际并不会中断，只是将中断标志设置为true），如果线程正处在sleep(),join(),wait()方法中时（也就是正在阻塞中）调用该方法，该方法会抛出异常。
- t.interrupted():检测该线程是否已经中断（对中断标志位不作处理）
- t.isAlive()：检测该线程是否还活着
- t.isDaemon()：检测该线程是否为守护线程
- t.isInterrupted()：检测该线程是否已经中断
- t.join():在a线程中调用b.join()，则a线程阻塞，直到b线程执行完
- t.join(long millis):和上面的方法一样，不过a线程阻塞的时间根据long的大小有关，如果达到设定的阻塞时间，就算b线程没有执行完，a线程也会被唤醒。
JDK5之后java.uti.concurrent包下面的一些工具类方便开发
- 线程池
①为什么需要线程池？
------- 主要是为了重复利用线程资源，减少系统在创建和销毁线程上所花的时间和开销；同时也可以限制资源过多，防止出现OOM或执行效率下降
②如何获取线程池？
在jdk5及以上版本中，使用java.util.concurrent.Executors类来创建线程池，该类提供了很多静态方法来创建线程池ExecutorService。
1、Executors.newFixedThreadPool(int) 创建一个最大规模固定的线程池，如果当前线程不够用且没有超过线程池限制数量，则创建新的线程。如果线程池已满，则会将任务放入等待队列。
2、Executors.newCachedThreadPool 创建一个最大规模可为Integer.MAX_VALUE 的可缓存的线程池。如果当前线程不够用就增加线程池中的线程数，如果当前线程池中线程过多，则会回收空的线程。
3、Executors.newSingleThreadExecutor创建一个单线程的线程池，确保任务串行
4、Executors.newScheduledThreadPool 创建一个固定大小的线程池，以延迟或者固定周期的方式执行，类似于定时器。
③执行任务和关闭线程池
e.execute(Runnable r) :执行任务无返回值
e.submit(Runnable r) :执行任务返回Future<?> ,实际上是null
e.submit(Runnable r,T result) : 执行任务返回Future
e.submit(Callable c) :执行返回Future<？>
e.invokeAny(Collection<? extends Callable > c):随机执行集合中的一个任务，返回T。如果其中一个任务执行结束(或者抛了一个异常)，其他 Callable 将被取消。
e.invokeAll(Collection<? extends Callable > c)：执行集合中所有的任务，返回List<Future>
e.shutdown():调用该方法后线程池立刻变成shutdown状态，不能再往线程池中增加新的任务否则将会抛出RejectedExecutionException异常，等所有进入队列的任务都执行完毕后关闭线程池
e.shutdownNow()：调用该方法后，线程池立刻变成stop状态，停止接受新的任务，并且试图停止所有正在执行的任务（使用的是Thread.interrupt()方法，不一定能中断正在执行的线程），不会执行等待队列中的任务，然后关闭线程池。
public class Test7 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//获取当前系统cpu的数目
int availableProcessors = Runtime.getRuntime().availableProcessors();
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(availableProcessors);
fixedThreadPool.execute(new MyThread7());
fixedThreadPool.shutdown();
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
Future<?> future = singleThreadExecutor.submit(new MyThread7());
Future<?> future2 = singleThreadExecutor.submit(new MyThread8());
System.out.println("future: "+future.get());
System.out.println("future2: "+future2.get());
singleThreadExecutor.shutdown();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
String result = "这是result";
Future<String> submit = cachedThreadPool.submit(new MyThread7(),result);
System.out.println("..."+submit.get());
cachedThreadPool.shutdown();
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(availableProcessors);
//初始延迟3秒钟，只执行一次
scheduledThreadPool.schedule(new MyThread8(), 3, TimeUnit.SECONDS );
//初始延迟2秒中，每5秒执行一次
scheduledThreadPool.scheduleWithFixedDelay(new FixedDelay(), 2, 5, TimeUnit.SECONDS);
//初始延迟1秒钟，每4秒中执行一次
scheduledThreadPool.scheduleAtFixedRate(new FixedRate(), 1, 4, TimeUnit.SECONDS);
Thread.sleep(20000);
scheduledThreadPool.shutdown();
}
}
class MyThread7 implements Runnable{
@Override
public void run() {
System.out.println("执行代码:"+System.currentTimeMillis()/1000);
}
}
class MyThread8 implements Callable<String>{
@Override
public String call() {
System.out.println("执行代码:"+System.currentTimeMillis()/1000);
return "执行完成";
}
}
class FixedDelay implements Runnable{
@Override
public void run() {
System.out.println("FixedDelay执行代码:"+System.currentTimeMillis()/1000);
}
}
class FixedRate implements Runnable{
@Override
public void run() {
System.out.println("FixedRate执行代码:"+System.currentTimeMillis()/1000);
}
}
执行结果：
执行代码:1523348201
执行代码:1523348201
future: null
执行代码:1523348201
future2: 执行完成
执行代码:1523348201
...这是result
FixedRate执行代码:1523348202
FixedDelay执行代码:1523348203
执行代码:1523348204
FixedRate执行代码:1523348206
FixedDelay执行代码:1523348208
FixedRate执行代码:1523348210
FixedDelay执行代码:1523348213
FixedRate执行代码:1523348214
FixedRate执行代码:1523348218
FixedDelay执行代码:1523348218
④ThreadPoolExecutor学习
其实通过源码可知newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 三种线程池的创建都是通过调用如下的方法来创建的。
public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
int maximumPoolSize,//最大线程池大小
long keepAliveTime,//线程执行完成后在线程池中的缓存时间，也就是线程空闲多长时间后会被回收
TimeUnit unit,//时间单位TimeUnit.SECONDS
BlockingQueue<Runnable> workQueue,//线程缓冲队列，当线程池线程运行超过一定线程时并满足一定的条件，待运行的线程会放入到这个队列
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
线程池总结：
ThreadPoolExecutor对象初始化时，不创建任何执行线程，当有新任务进来时，才会创建线程来执行任务。当目前执行线程的总数小于核心线程大小时，所有新加入的任务，都会创建新线程来处理。当目前执行线程的总数大于或等于核心线程时，所有新加入的任务，都放入任务缓存队列中。当目前执行线程的总数大于或等于核心线程，并且缓存队列已满，同时此时线程总数小于线程池的最大规模，那么创建新线程，协助处理新的任务。当所有线程都在执行，线程池大小已经达到上限，并且缓存队列已满时，就rejectHandler拒绝新的任务。
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
