创建线程的方式:继承Thread 、 实现Runnable接口 、实现Callable接口(可以通过Future获取返回结果)
介绍一下通过Callable实现多线程:
public class ThreadC implements Callable {
public Object call() throws Exception {
System.out.println("线程执行");
return "线程返回结果";
}
public static void main(String []args){
ThreadC threadC=new ThreadC();
FutureTask futureTask=new FutureTask(threadC);
new Thread(futureTask).start();
try {
Object obj=futureTask.get();
System.out.println(obj);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//输出结果
线程执行
线程返回结果
线程之间的状态转换(线程的状态:创建 就绪 执行 阻塞 终止)
对于线程中常用的方法有:
sleep():当前线程休眠,但对象锁保持不放
wait():,通常在和notify()一起作用在synchronized方法中,在执行完后让线程进入等待队列
notify:唤醒在此对象监听器的线程,如果有多个则随机唤醒一个
yeild():线程让步,暂停当前线程,让同级或更高优先级线程执行
join():当前线程进入阻塞,等待其他线程终止
interrupt():中断线程信号
线程同步:
线程的特点 :可见性 有序性 在不同步处理情况下多个线程并发执行的时候造成执行顺序随机,变量数据不可靠
public class ThreadD{
public /*synchronized */ void print(String name){ //传入字符串,按字符输出
for(int i=0;i<name.length();i++){
System.out.print(name.charAt(i));
}
}
public static void main(String []args){
final ThreadD threadD=new ThreadD();
Thread a=new Thread(new Runnable() { //创建两个线程执行print()方法,预期输出lisizhangsan,不在print方法加synchronized时输出结果就会变得随机
public void run() {
threadD.print("lisi");
}
});
Thread b=new Thread(new Runnable() {
public void run() {
threadD.print("zhangsan");
}
});
a.start();
b.start();
}
}
synchronized关键字的作用域有二种:
1)是某个对象实例内,synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法)。这时,不同的对象实例的synchronized方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法;
2)是某个类的范围,synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized关键字,synchronized关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/},它的作用域是当前对象;
3、synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法;
该部分文字引入来源: 原文:https://blog.csdn.net/evankaka/article/details/44153709
如何启动三个线程按顺序打印ABC:
public class ThreadB implements Runnable{
private String name;
private Object pre;
private Object self;
public ThreadB(String name, Object pre, Object self) {
this.name = name;
this.pre = pre;
this.self = self;
}
public void run() {
synchronized (pre){
synchronized (self){
System.out.println(name);
self.notify();
}
try {
pre.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String []args){
Object a=new Object();
Object b=new Object();
Object c=new Object();
ThreadB ta=new ThreadB("A",b,c);
ThreadB tb=new ThreadB("B",c,a);
ThreadB tc=new ThreadB("C",a,b);
for(int i=0;i<10;i++){
new Thread(ta).start();
new Thread(tb).start();
new Thread(tc).start();
}
}
}
线程池原理
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSize:线程池核心线程数量
maximumPoolSize:线程池最大线程数量
keepAliverTime:当活跃线程数大于核心线程数时,空闲的多余线程最大存活时间
unit:存活时间的单位
workQueue:存放任务的队列
handler:超出线程范围和队列容量的任务的处理程序
线程池的实现原理 文字引入来源: https://www.cnblogs.com/dongguacai/p/6030187.html
提交一个任务到线程池中,线程池的处理流程如下:
1、判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。
2、线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。
3、判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。
RejectedExecutionHandler:饱和策略
当队列和线程池都满了,说明线程池处于饱和状态,那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy,表示无法处理新的任务而抛出异常。JAVA提供了4中策略:
1、AbortPolicy:直接抛出异常
2、CallerRunsPolicy:只用调用所在的线程运行任务
3、DiscardOldestPolicy:丢弃队列里最近的一个任务,并执行当前任务。
4、DiscardPolicy:不处理,丢弃掉。
ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池
ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配
ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池,如果当前线程在执行任务时突然中断,则会创建一个新的线程替代它继续执行任务
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器