Java学习笔记之多线程 2
2015-06-01 11:13
525 查看
多线程学习笔记二
一、线程间通信
线程间通信,其实就是多个线程在操作同一个资源,但是操作的动作不同。
1.1等待唤醒机制:
测试案例1:生产者生产一部手机,消费者就购买一部手机
//测试类
public
class PhoneTest {
public
static void main(String[]
args) {
//手机对象(锁对象)
Phone p = new Phone();
//生产者
SetPhone set =
new SetPhone(p);
//消费者
GetPhone get =
new GetPhone(p);
//创建线程对象
Thread setThread =
new Thread(set,"生产者");
Thread getThread =
new Thread(get,"消费者");
//启动线程
setThread.start();
getThread.start();
}
}
//手机类:共享资源
public
class Phone {
private Stringbrand;
private Stringcolor;
private
boolean isNewPhone = false;//默认没有生产手机
//生产手机函数,同步函数的锁是this
public
synchronized void set(String
brand, String color) {
//是否有新手机
if (this.isNewPhone) {
try {
this.wait();//锁对象调用Object类中的wait方法,让生产者处于等待状态。注意:锁对象可以是任意对象
} catch (InterruptedExceptione) {
e.printStackTrace();
}
}
//如果到了当前代码位置,说明没有新手机,要生产新手机
this.brand =brand;
this.color =color;
//模拟生产手机的耗时操作
try {
Thread.sleep(1000);
} catch(InterruptedExceptione) {
e.printStackTrace();
}
//打印生产后的信息
System.out.print(Thread.currentThread().getName());//生产者线程名称
System.out.println("生产了:" +this.brand
+ "---" + this.color);
//手机生产完成,把手机状态更新为有新手机 true
this.isNewPhone =true;
//唤醒消费者,有新手机了,可以购买
this.notify();
}
//购买手机函数,同步函数锁是this
public
synchronized void get() {
//判断是否有新手机
if (!this.isNewPhone) {
try {
this.wait();//没有手机,消费者处于等待状态
} catch(InterruptedExceptione) {
e.printStackTrace();
}
}
//执行到了当前代码,说明目前有手机了
//购买手机
try {
Thread.sleep(1000);
} catch(InterruptedExceptione) {
e.printStackTrace();
}
//打印购买后的信息
System.out.print(Thread.currentThread().getName());//消费者
System.out.println("购买了:" +this.brand
+"---" +this.color);
//手机被买走了,更新手机的状态,false
this.isNewPhone =false;
//唤醒生产者,该生产新手机了
this.notify();
}
}
//生产者类
public
class SetPhone implements Runnable {
Phone phone ;
int
num = 0;//线程体中的代码切换
//构造函数
public SetPhone(Phonep) {
phone =
p;
}
//重写run方法
public
void run() {
while (true) {
if (num %2 == 0) {//线程体切换条件
phone.set("小米4","蓝色");//生产小米手机
} else {
phone.set("iPhone6","黄色");//生产苹果手机
}
num++;
}
}
}
//消费者类
public
class GetPhone implements Runnable {
Phone phone;
//构造函数
public GetPhone(Phonep) {
phone =
p;
}
//重写run方法
public
void run() {
while (true) {
phone.get();//消费手机
}
}
}
输出结果:
生产者生产了:小米4---蓝色
消费者购买了:小米4---蓝色
生产者生产了:iPhone6---黄色
消费者购买了:iPhone6---黄色
...
由输出结果可知:生产者生产了一部手机,就通知消费者来买手机,在等待消费者买手机的过程中,生产者停止生产,处于等待状态;消费者收到通知后,便来买手机,买完手机后也通知生产者没手机了,该生产手机了,于是消费者停止购买,处于等待状态,等待生产者生产手机...依此循环下去。程序执行过程如图1所示。
![](http://img.blog.csdn.net/20150601111448838?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbGVleml5dWFu/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
图1
注意:本例是在只有2个线程的理想情况下,实际中可能会有多个线程。
测试案例2:生产者与消费者升级版,JDK1.5中的新特性来处理,多个生产者,多个消费者的同步问题。
//测试类
classProducerConsumerDemo {
public static void main(String[] args) {
//创建共享资源对象
Resource r = new Resource();
//生产者对象
Producer pro = new Producer(r);
//消费者对象
Consumer con = new Consumer(r);
//创建线程对象
Thread t1 = new Thread(pro);//生产者1
Thread t2 = new Thread(pro);//生产者2
Thread t3 = new Thread(con);//消费者1
Thread t4 = new Thread(con);//消费者2
//开启线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//JDK1.5中提供了多线程升级解决方案。
//共享资源
classResource {
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();//创建lock对象
//生产者锁对象
private Condition condition_pro =lock.newCondition();
//消费者锁对象
private Condition condition_con =lock.newCondition();
//生产商品函数
public void set(String name)throws InterruptedException {
lock.lock();//上锁
try {
while(flag) {//有商品
condition_pro.await();//等待,不生产
}
// 执行到当前代码说明没有商品,开始生产商品
this.name =name+"--"+count++;
//模拟生产手机的耗时操作
try {
Thread.sleep(500);
}catch(InterruptedException e){
e.printStackTrace();
}
//打印生产后的信息
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
//产品生产完成,把产品状态更新为有新产品:true
flag = true;
//唤醒消费者,有新产品,可以购买了
condition_con.signal();
}
Finally {
lock.unlock();//解锁,释放锁的动作一定要执行。
}
}
//消费商品函数
public void out()throws InterruptedException {
lock.lock(); //上锁
try {
while(!flag){//判断是否有新产品
condition_con.await();//没有新产品,消费者处于等待状态
}
//执行到了当前代码,说明目前有产品,可以购买了
//模拟购买产品的耗时动作
try {
Thread.sleep(500);
}catch(InterruptedException e){
e.printStackTrace();
}
//打印购买后的信息
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
//产品被买走了,更新产品的状态,false
flag = false;
//唤醒生产者,该生产新产品了
condition_pro.signal();
}
Finally {
lock.unlock();//解锁
}
}
}
//生产者类
classProducer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res = res;
}
//重写run方法
public void run() {
while(true) {
try{
res.set("+商品+");
}
catch (InterruptedException e) {
//不处理
}
}
}
}
//消费者类
classConsumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
try {
res.out();
} catch (InterruptedException e) {
//不处理异常
}
}
}
}
输出结果
Thread-0...生产者..+商品+--1
Thread-2...消费者.........+商品+--1
Thread-1...生产者..+商品+--2
Thread-3...消费者.........+商品+--2
Thread-0...生产者..+商品+--3
Thread-2...消费者.........+商品+--3
Thread-1...生产者..+商品+--4
Thread-3...消费者.........+商品+--4
...
二、Object类中和线程相关的方法
public final void wait()//在其他线程调用此对象的notify()方法或 notifyAll()方法前,导致当前线程等待
public final void wait(long timeout)//单位:ms
//在其他线程调用此对象的notify()方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。该方法等价于Thread类中sleep(long timeout)
public final void wait(long timeout,int nanos)
//在其他线程调用此对象的notify() 方法或 notifyAll()方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量前,导致当前线程等待。该方法等价于 Thread类中sleep(longtimeout,int nanos)
public final void notify()//唤醒在此对象监视器(锁对象)上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。选择是任意性的
publicfinal void notifyAll() //唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法,在对象的监视器上等待。
sleep()与 wait()的区别,notify()的作用?
sleep():让线程处于暂时休眠状态,当时间到达后,自动醒来运行线程对象。注意:在线程处理休眠状态的过程中,不会释放锁对象,会释放CPU执行权
wait():让线程处于等待状态,需要被其他线程对象,通过notify()或者notifyAll()进行唤醒,醒来后运行线程对象。 注意:在线程处理等待状态的过程中,会释放锁对象,会释放CPU执行权。
notify():唤醒处于等待状态的线程。 注意:当把一个等待状态的线程唤醒后,不会立刻执行该线程,会先获取锁对象,获取到锁对象和CPU执行权后,才会执行线程。
三、线程其他操作
1、停止线程
停止线程其实只有一种方法,就是让run方法结束。让run方法结束有一下3种方式:
1.1、定义循环结束标记,因为线程运行代码一般都是循环,只要控制了循环即可。注意:特殊情况,当线程处于了冻结状态,就不会读取到标记。那么线程就不会结束。
1.2、使用interrupt(中断)方法,该方法让处于冻结状态的线程,强制回到运行状态中来。
1.3、Thread类中的stop方法,此方法已经过时不再使用。
测试案例3:
class StopThread implements Runnable {
private booleanflag = true;
publicsynchronized void run() {
while(flag) {
try{
wait();//当线程处于了冻结状态,就不会读取到标志位。那么线程就不会结束
}catch(InterruptedExceptione){
System.out.println(Thread.currentThread().getName()+"....Exception");
flag =false;//线程被强制醒来后,可以操作标记让线程结束
}
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public voidchangeFlag() {
flag = false;
}
}
//测试类
class StopThreadDemo {
public staticvoid main(String[] args) {
//创建自定义类对象
StopThread st= new StopThread();
//创建自定义类对象
Thread t1 =new Thread(st);
Thread t2 =new Thread(st);
//创建线程对象
t1.setDaemon(true);
t2.setDaemon(true);
//开启线程
t1.start();
t2.start();
int num = 0;
while(true) {
if(num++== 60) {
t1.interrupt();//把处于冻结状态的线程强制恢复到运行态
t2.interrupt();
break; //退出死循环
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("mainover");//主线程执行完毕标志
}
}
输出结果:
main.......58
main.......59
main.......60
main over
Thread-0....Exception
Thread-0....run
Thread-1....Exception
Thread-1....run
2、守护线程
简介:相当于后台线程,任然会和前台线程(例如主线程)抢夺CPU资源(具备执行权),但是,当所有的前台线程都结束后,后台线程会自动结束。后台线程和前台线程有一种依赖关系。
public final void setDaemon(boolean on) // 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。该方法必须在启动线程前调用。
public final boolean isDaemon() //测试该线程是否为守护线程
测试案例4:
//1自定义类实现runnable接口
classStopThread implements Runnable {
privateboolean flag =true;
//2重写run方法
public voidrun() {
while(flag){
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public voidchangeFlag() {
flag =false;
}
}
//测试类
class StopThreadDemo {
publicstatic void main(String[] args) {
//3创建自定义类对象
StopThreadst = new StopThread();
//4创建线程对象
Threadt1 = new Thread(st);
Threadt2 = new Thread(st);
//5设置为守护线程,必须在启动线程前完成
t1.setDaemon(true);
t2.setDaemon(true);
//如果自定义线程都是守护线程,那么程序执行完主线程后,JVM虚拟机就直接退出,不再执行自定义线程了。
//6启动线程
t1.start();
t2.start();
int num= 0;
while(true){
if(num++== 60) {
break;//退出死循环
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("mainover");//主线程执行完毕标志
}
}
输出结果:
main.......59
Thread-1....run
main.......60
Thread-0....run
main over //主线程结束
Thread-1....run
Thread-0....run
请按任意键继续. . .
由输出结果可知:当主线程结束时,守护线程也随之结束。
3、Join方法
简介:当A线程执行到了B线程的.join()方法时,A就会等待。等B线程都执行完,A才会执行。join可以用来临时加入线程执行。
public final void join()
测试案例5:
//自定义类
class Demo implements Runnable{
//重写run方法
public void run() {
for(int x=0; x<70; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
//测试类
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t1.join();//会抛出异常,t1抢到主线程的CPU执行权开始执行(此时主线程处于冻结状态),等线程t1执行完毕后其他线程才能继续执行。也就是说主线程要等到t1挂掉后他才能运行。
t2.start();
//t1.join();//当t1在此处加入线程时,主线程处于冻结状态,线程t1,t2处于就绪态,那么t1,t2两个线程在CPU的切换下轮流执行。当t1执行完毕,不管t2是否执行完毕,主线程已经“活过来了”,此时主线程和t2处于抢夺cpu的状态,这两个线程在CPU的切换下执行直到所有线程都结束为止。
//主线程
for(int x=0; x<80; x++) {
System.out.println("main....."+x);
}
System.out.println("over");
}
}
输出结果:略
4、Priority和yield方法
优先级表示抢夺CPU的频率。优先级从1-10,1级最低,10级最高,所有的线程的默认优先级都是5。
publicfinal void setPriority(int newPriority)//更改线程的优先级
publicstatic void yield()//暂停当前正在执行的线程对象,并执行其他线程。Yield:放弃
测试案例6:
//自定义类实现runnable接口
class Demo implements Runnable {
public void run() {
for(int x=0; x<70; x++) {
System.out.println(Thread.currentThread().toString()+"....."+x);
//Thread.yield();//临时释放CPU执行权,减缓线程的运行,让线程都有机会平均运行的效果。
}
}
}
//测试类
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
//当数据是固定时就定义成常量,当数据是共享时就定义成static
t1.setPriority(Thread.MAX_PRIORITY);//把t1设置为最高优先级
t2.start();
//主线程
for(int x=0; x<80; x++) {
//不操作
}
System.out.println("over");
}
}
四、匿名内部类方式使用多线程
方式1:
new Thread(){重写run方法...}.start();
方式2:
New Thread(new Runnable(){重写run方法...}).start();
测试案例7:
public
class ThreadDemo {
public
static void main(String[]
args) {
//匿名内部类,Thread类的子类
new Thread(){
//Thread类的匿名子类对象
public
void run() {
System.out.println("Thread匿名内部类对象");
};
}.start();
//匿名内部类方式,实现Runnable接口,父类引用指向子类对象
new Thread(new Runnable() {
@Override
public
void run() {
System.out.println("Runnable接口匿名内部类子类对象");
}
}).start();
}
}
五、线程组
5.1线程组简介:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。默认情况下,所有的线程都属于主线程组。从JDK1.0开始。
5.2 ThreadGroup构造方法:
publicThreadGroup(Stringname)//构造一个新线程组。新线程组的父线程组是目前正在运行线程的线程组
publicThreadGroup(ThreadGroup parent,Stringname)//创建一个新线程组。新线程组的父线程组是指定的线程组
5.3 ThreadGroup常用方法
publicfinal
StringgetName()//返回此线程组的名称
5.3Thread类有关线程组的构造方法:
public Thread(ThreadGroupgroup, String name)
public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group,Runnable target, String name)
//给线程设置分组。
5.4 Thread类有关线程组的常用方法
publicfinal ThreadGroup getThreadGroup()//返回该线程所属的线程组
5.5测试案例:
public
class ThreadDemo {
public
static void main(String[]
args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
//创建一个线程组
MyThreadGroupgroup =
new MyThreadGroup("javaEE");
//创建一个新的线程对象,并把该线程对象设置为javaEE组的成员
MyThread t3 = new MyThread(group,"se");
t3.start();
}
}
//线程类
public
class MyThread extends Thread {
public MyThread() {
super();
}
publicMyThread(ThreadGroupgroup, String
name) {
super(group,name);
}
public
void run() {
System.out.println("当前线程的名字是:" + getName());
//获取到线程组对象
ThreadGroup threadGroup =this.getThreadGroup();
//获取线程组的名字
String name =
threadGroup.getName();
System.out.println("当前线程对象所在的组名是: " +name);
}
}
//线程组类
public
class MyThreadGroup extends ThreadGroup {
publicMyThreadGroup(Stringname) {
super(name);
}
}
六、线程池
6.1简介:程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。
JDK5新增了一个Executors(执行者)工厂类来产生线程池。
6.2 Executors类的构造方法:无
6.3 Executors类的常用方法:
publicstatic ExecutorService newCachedThreadPool()//创建一个具有高效缓存功能的线程池对象
publicstatic ExecutorService newFixedThreadPool(int nThreads)//创建一个可重用的线程池,具有固定(Fixed)线程数的线程池,n为1时也可以创建单个线程对象的线程池
publicstatic ExecutorService newSingleThreadExecutor()//创建单个线程对象的线程池对象。
这些方法的返回值是ExecutorService(线程池)对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。
ExecutorService接口常用方法:(JDK1.5)
注意:ExecutorService直译为“执行者服务”在java中叫线程池。
Future<?>submit(Runnable task)//提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。(submit:提交)
<T>Future<T> submit(Callable<T> task)// 提交一个 Runnable任务用于执行,并返回一个表示该任务的 Future。
Future<V>接口简介(jdk1.5)
Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。计算完成后只能使用 get 方法来获取结果,如有必要,计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。
6.4 测试案例
//1、自定义类,实现runnable接口
public
class MyRunnable implements Runnable {
//2、重写run方法,线程体
public
void run() {
System.out.println("我是线程体");
//获取线程名字
System.out.println(Thread.currentThread().getName());
}
}
//测试类
public
class ThreadPool {
public
static void main(String[]
args) {
//3、用Executors类中的newFixedThreadPool()方法创建带有2个线程对象的线程池对象(用方法的返回值"创建"对象)。
ExecutorServiceservice = Executors.newFixedThreadPool(2);
//4、将线程体对象当做参数传递给ExecutorService接口中的submit()方法,来启动线程,执行现场体。
//submit()方法相当于Thread类中的start()方法.
service.submit(new MyRunnable());
service.submit(new MyRunnable());
}
}
输出结果:
我是线程体
我是线程体
pool-1-thread-2
pool-1-thread-1
七、java多线程实现方式3,实现Callable接口
1 简介:
通过线程池对象,实现Callable(随时可偿还的)接口。Callable接口类似于Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。从JDK1.5开始。
2构造方法:无
3 普通方法:
V call()//计算结果,如果无法计算结果,则抛出一个异常.相当于runnable接口中的run方法。
4 创建线程的步骤:
1) 自定义类实现Runnable接口
2) 重写call方法
3) 创建线程池对象
4) 实现线程池中的线程对象,来执行线程要执行的代码
5测试案例:
//1、自定义类实现Callable接口
public
class MyCallable implementsCallable{
//2、重写call方法,相当于Runnable接口中的run()方法
public Object call()throws Exception {
System.out.println("创建线程的第三种方法,通过线程池对象实现Callable接口");
System.out.println(Thread.currentThread().getName());
return
null;
}
}
//测试类
public
class ThreadTest {
public
static void main(String[]
args) {
//3、创建线程池对象
ExecutorServiceservice = Executors.newFixedThreadPool(2);
//4、实现线程池中的线程对象,来执行线程要执行的代码
service.submit(new MyCallable());
service.submit(new MyCallable());
}
}
输出结果:
![](http://img.blog.csdn.net/20150601112503831?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbGVleml5dWFu/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
由输出结果可知:程序一直处于等待状态。
八、定时器:
1 简介:定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能。
2 Timer类
一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。位于java.util包中。从JDK1.3开始。
Timer类构造方法:
public Timer()//创建一个新计时器
常用方法:
publicvoid schedule(TimerTask task, long delay) //在指定的时间到达后,执行TimerTask中的run方法
public void schedule(TimerTask task,longdelay,long period)//在指定的时间到达后,执行TimerTask中的run方法,并且以后每隔固定的时间重复执行
3 TimerTask类
是一个抽象类。由Timer 安排为一次执行或重复执行的任务,位于java.util包中,从JDK1.3开始。
TimerTask构造方法:
protected TimerTask()//创建一个新的计时器任务
TimerTask常用方法:
public abstract void run()//此计时器任务要执行的操作。
public boolean cancel()//取消此计时器任务。
备注:在android开发中Quartz是一个完全由java编写的开源调度框架。
4 测试案例:设置一个定时器,5秒钟后闹钟响起,以后每隔3秒响一次。
public
class TimerDemo {
public
static void main(String[]
args) {
//1、创建timer对象
Timer timer = new Timer();
//2、匿名方式创建TimerTask对象
TimerTask task =
new TimerTask() {
//3、重写run()方法,准备好定时器Timer要执行的内容(任务)
public
void run() {
System.out.println("除非你能在床上挣钱,否则就别赖在床上不起");
}
};
//4、执行任务
timer.schedule(task, 5000, 3000);
}
}
九、设计模式
1概述:
设计模式(Designpattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让带码更容易被他人理解、保证代码可靠性。
设计模式不是一种方法和技巧,而是一种思想。
设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,实现低耦合,高内聚。
2设计模式分类:
创建型模式:简单工程模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式(6个)
行为型模式:模板方法模式,观察者模式,状态模式,职责链模式,命令模式,访问者模式,策略模式,备忘录模式,迭代器模式,解释器模式(10个)
结构型模式:外观模式,适配器模式,代理模式,装饰模式,桥接模式,组合模式,享元模式(7个)
备注:红色为实际编程中常用的设计模式。
3单例设计模式:
概述:在内存中一个类只能有一个实例对象。
分类:
饿汉式:创建步骤 1、构造方法私有,2、在本类中创建本类对象,3、对外提供公共访问方法,用来获取当前类对象。
懒汉式:创建步骤1、构造方法私有,2、在本类中创建本类的对象引用,而不是创建对象,3、对外提供公共访问方法,用来获取当前类对象,3.1如果是第一次访问方法,完成对象的创建,3.2如果不是第一次访问对象,返回创建好的对象。
测试案例1:创建饿汉式单例设计模式
//饿汉式
public
class Single {
//1、构造方法私有
private Single(){}
//2、在本类中,创建本类对象
private
static Single s =
new Single();
//3、对外提供公共访问方法,用来获取当前类对象
public
static SinglegetInstance(){
returns;
}
}
//测试类
public
class Test {
public
static void main(String[]
args) {
//
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1 ==s2);//判断对象引用s1、s2指向的地址是否相等
System.out.println(s1);
System.out.println(s2);
}
}
输出结果:
true
Single@659e0bfd
Single@659e0bfd
由输出结果可知,s1、s2指向堆中同一块内存地址。
测试案例2:创建懒汉式单例设计模式
//懒汉式
public
class Single2 {
//构造方法私有
private Single2(){}
//在本类中,创建本类对象的引用,而不创建对象
private
static Single2 s =
null;
//对外提供公共访问方法,用来获取当前类对象
public
synchronized static Single2getInstance(){
if (s ==null) {
//t1, t2
//如果是第一次访问方法:完成对象的创建
s =
new Single2();
}
//如果不是第一次访问方法,返回创建好的对象
returns;
}
}
//测试类
public
class Test2 {
public
static void main(String[]
args) {
Single2 s1 = Single2.getInstance();
Single2 s2 = Single2.getInstance();
System.out.println(s1 ==s2);
System.out.println(s1);
System.out.println(s2);
}
}
输出结果
true
Single2@659e0bfd
Single2@659e0bfd
由输出结果可知,s1、s2指向堆中同一块内存地址。
注意:在多线程的情况下,懒汉式的会有线程安全问题,饿汉式没有线程安全问题。开发的时候用饿汉式。
十、多线程常见问题
1多线程有几种实现方案,分别是哪几种?
答:3种,
方式一:继承Thread类,重写run方法
方式二:实现Runnable接口,实现run方法
方式三:通过线程池,实现Callable接口,实现call()方法。
2同步有几种方式,分别是什么?
答:3种
方式一:同步代码块,锁对象是任意的
方式二:同步函数,普通同步函数的锁对象是this,静态同步函数的锁是类名.class
方式三:Lock锁
当一个程序有多个线程操作同一个共享数据时,要求线程对象所使用的是同一把锁对象。
3 启动一个线程是run()还是start()?它们的区别?
答:启动一个线程是start()方法,
run()方法是线程要执行的操作,线程体
start()方法启动线程,告诉JVM调用run()方法。
4 sleep()和wait()方法的区别?
答:sleep()方法是让线程休眠指定的时间,时间到后自动醒来。在线程休眠的过程中不会释放锁对象,但会释放CPU执行权。
wait()方法是让线程处于等待状态,当设置指定的时间,时间到后会自动醒来,如果没有设置等待时间,则必须由notify()或notifyAll()方法来唤醒。在线程等待的过程中会释放CPU的执行权和锁对象。
5 为什么wait(),notify(),notifyAll()等方法都定义在Object类中
答:因为这些方法的调用,要使用当前线程中的锁对象来调用,而锁对象的类型是任意对象,所以,放在Object类中。
一、线程间通信
线程间通信,其实就是多个线程在操作同一个资源,但是操作的动作不同。
1.1等待唤醒机制:
测试案例1:生产者生产一部手机,消费者就购买一部手机
//测试类
public
class PhoneTest {
public
static void main(String[]
args) {
//手机对象(锁对象)
Phone p = new Phone();
//生产者
SetPhone set =
new SetPhone(p);
//消费者
GetPhone get =
new GetPhone(p);
//创建线程对象
Thread setThread =
new Thread(set,"生产者");
Thread getThread =
new Thread(get,"消费者");
//启动线程
setThread.start();
getThread.start();
}
}
//手机类:共享资源
public
class Phone {
private Stringbrand;
private Stringcolor;
private
boolean isNewPhone = false;//默认没有生产手机
//生产手机函数,同步函数的锁是this
public
synchronized void set(String
brand, String color) {
//是否有新手机
if (this.isNewPhone) {
try {
this.wait();//锁对象调用Object类中的wait方法,让生产者处于等待状态。注意:锁对象可以是任意对象
} catch (InterruptedExceptione) {
e.printStackTrace();
}
}
//如果到了当前代码位置,说明没有新手机,要生产新手机
this.brand =brand;
this.color =color;
//模拟生产手机的耗时操作
try {
Thread.sleep(1000);
} catch(InterruptedExceptione) {
e.printStackTrace();
}
//打印生产后的信息
System.out.print(Thread.currentThread().getName());//生产者线程名称
System.out.println("生产了:" +this.brand
+ "---" + this.color);
//手机生产完成,把手机状态更新为有新手机 true
this.isNewPhone =true;
//唤醒消费者,有新手机了,可以购买
this.notify();
}
//购买手机函数,同步函数锁是this
public
synchronized void get() {
//判断是否有新手机
if (!this.isNewPhone) {
try {
this.wait();//没有手机,消费者处于等待状态
} catch(InterruptedExceptione) {
e.printStackTrace();
}
}
//执行到了当前代码,说明目前有手机了
//购买手机
try {
Thread.sleep(1000);
} catch(InterruptedExceptione) {
e.printStackTrace();
}
//打印购买后的信息
System.out.print(Thread.currentThread().getName());//消费者
System.out.println("购买了:" +this.brand
+"---" +this.color);
//手机被买走了,更新手机的状态,false
this.isNewPhone =false;
//唤醒生产者,该生产新手机了
this.notify();
}
}
//生产者类
public
class SetPhone implements Runnable {
Phone phone ;
int
num = 0;//线程体中的代码切换
//构造函数
public SetPhone(Phonep) {
phone =
p;
}
//重写run方法
public
void run() {
while (true) {
if (num %2 == 0) {//线程体切换条件
phone.set("小米4","蓝色");//生产小米手机
} else {
phone.set("iPhone6","黄色");//生产苹果手机
}
num++;
}
}
}
//消费者类
public
class GetPhone implements Runnable {
Phone phone;
//构造函数
public GetPhone(Phonep) {
phone =
p;
}
//重写run方法
public
void run() {
while (true) {
phone.get();//消费手机
}
}
}
输出结果:
生产者生产了:小米4---蓝色
消费者购买了:小米4---蓝色
生产者生产了:iPhone6---黄色
消费者购买了:iPhone6---黄色
...
由输出结果可知:生产者生产了一部手机,就通知消费者来买手机,在等待消费者买手机的过程中,生产者停止生产,处于等待状态;消费者收到通知后,便来买手机,买完手机后也通知生产者没手机了,该生产手机了,于是消费者停止购买,处于等待状态,等待生产者生产手机...依此循环下去。程序执行过程如图1所示。
图1
注意:本例是在只有2个线程的理想情况下,实际中可能会有多个线程。
测试案例2:生产者与消费者升级版,JDK1.5中的新特性来处理,多个生产者,多个消费者的同步问题。
//测试类
classProducerConsumerDemo {
public static void main(String[] args) {
//创建共享资源对象
Resource r = new Resource();
//生产者对象
Producer pro = new Producer(r);
//消费者对象
Consumer con = new Consumer(r);
//创建线程对象
Thread t1 = new Thread(pro);//生产者1
Thread t2 = new Thread(pro);//生产者2
Thread t3 = new Thread(con);//消费者1
Thread t4 = new Thread(con);//消费者2
//开启线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//JDK1.5中提供了多线程升级解决方案。
//共享资源
classResource {
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();//创建lock对象
//生产者锁对象
private Condition condition_pro =lock.newCondition();
//消费者锁对象
private Condition condition_con =lock.newCondition();
//生产商品函数
public void set(String name)throws InterruptedException {
lock.lock();//上锁
try {
while(flag) {//有商品
condition_pro.await();//等待,不生产
}
// 执行到当前代码说明没有商品,开始生产商品
this.name =name+"--"+count++;
//模拟生产手机的耗时操作
try {
Thread.sleep(500);
}catch(InterruptedException e){
e.printStackTrace();
}
//打印生产后的信息
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
//产品生产完成,把产品状态更新为有新产品:true
flag = true;
//唤醒消费者,有新产品,可以购买了
condition_con.signal();
}
Finally {
lock.unlock();//解锁,释放锁的动作一定要执行。
}
}
//消费商品函数
public void out()throws InterruptedException {
lock.lock(); //上锁
try {
while(!flag){//判断是否有新产品
condition_con.await();//没有新产品,消费者处于等待状态
}
//执行到了当前代码,说明目前有产品,可以购买了
//模拟购买产品的耗时动作
try {
Thread.sleep(500);
}catch(InterruptedException e){
e.printStackTrace();
}
//打印购买后的信息
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
//产品被买走了,更新产品的状态,false
flag = false;
//唤醒生产者,该生产新产品了
condition_pro.signal();
}
Finally {
lock.unlock();//解锁
}
}
}
//生产者类
classProducer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res = res;
}
//重写run方法
public void run() {
while(true) {
try{
res.set("+商品+");
}
catch (InterruptedException e) {
//不处理
}
}
}
}
//消费者类
classConsumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
try {
res.out();
} catch (InterruptedException e) {
//不处理异常
}
}
}
}
输出结果
Thread-0...生产者..+商品+--1
Thread-2...消费者.........+商品+--1
Thread-1...生产者..+商品+--2
Thread-3...消费者.........+商品+--2
Thread-0...生产者..+商品+--3
Thread-2...消费者.........+商品+--3
Thread-1...生产者..+商品+--4
Thread-3...消费者.........+商品+--4
...
二、Object类中和线程相关的方法
public final void wait()//在其他线程调用此对象的notify()方法或 notifyAll()方法前,导致当前线程等待
public final void wait(long timeout)//单位:ms
//在其他线程调用此对象的notify()方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。该方法等价于Thread类中sleep(long timeout)
public final void wait(long timeout,int nanos)
//在其他线程调用此对象的notify() 方法或 notifyAll()方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量前,导致当前线程等待。该方法等价于 Thread类中sleep(longtimeout,int nanos)
public final void notify()//唤醒在此对象监视器(锁对象)上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。选择是任意性的
publicfinal void notifyAll() //唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法,在对象的监视器上等待。
sleep()与 wait()的区别,notify()的作用?
sleep():让线程处于暂时休眠状态,当时间到达后,自动醒来运行线程对象。注意:在线程处理休眠状态的过程中,不会释放锁对象,会释放CPU执行权
wait():让线程处于等待状态,需要被其他线程对象,通过notify()或者notifyAll()进行唤醒,醒来后运行线程对象。 注意:在线程处理等待状态的过程中,会释放锁对象,会释放CPU执行权。
notify():唤醒处于等待状态的线程。 注意:当把一个等待状态的线程唤醒后,不会立刻执行该线程,会先获取锁对象,获取到锁对象和CPU执行权后,才会执行线程。
三、线程其他操作
1、停止线程
停止线程其实只有一种方法,就是让run方法结束。让run方法结束有一下3种方式:
1.1、定义循环结束标记,因为线程运行代码一般都是循环,只要控制了循环即可。注意:特殊情况,当线程处于了冻结状态,就不会读取到标记。那么线程就不会结束。
1.2、使用interrupt(中断)方法,该方法让处于冻结状态的线程,强制回到运行状态中来。
1.3、Thread类中的stop方法,此方法已经过时不再使用。
测试案例3:
class StopThread implements Runnable {
private booleanflag = true;
publicsynchronized void run() {
while(flag) {
try{
wait();//当线程处于了冻结状态,就不会读取到标志位。那么线程就不会结束
}catch(InterruptedExceptione){
System.out.println(Thread.currentThread().getName()+"....Exception");
flag =false;//线程被强制醒来后,可以操作标记让线程结束
}
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public voidchangeFlag() {
flag = false;
}
}
//测试类
class StopThreadDemo {
public staticvoid main(String[] args) {
//创建自定义类对象
StopThread st= new StopThread();
//创建自定义类对象
Thread t1 =new Thread(st);
Thread t2 =new Thread(st);
//创建线程对象
t1.setDaemon(true);
t2.setDaemon(true);
//开启线程
t1.start();
t2.start();
int num = 0;
while(true) {
if(num++== 60) {
t1.interrupt();//把处于冻结状态的线程强制恢复到运行态
t2.interrupt();
break; //退出死循环
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("mainover");//主线程执行完毕标志
}
}
输出结果:
main.......58
main.......59
main.......60
main over
Thread-0....Exception
Thread-0....run
Thread-1....Exception
Thread-1....run
2、守护线程
简介:相当于后台线程,任然会和前台线程(例如主线程)抢夺CPU资源(具备执行权),但是,当所有的前台线程都结束后,后台线程会自动结束。后台线程和前台线程有一种依赖关系。
public final void setDaemon(boolean on) // 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。该方法必须在启动线程前调用。
public final boolean isDaemon() //测试该线程是否为守护线程
测试案例4:
//1自定义类实现runnable接口
classStopThread implements Runnable {
privateboolean flag =true;
//2重写run方法
public voidrun() {
while(flag){
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public voidchangeFlag() {
flag =false;
}
}
//测试类
class StopThreadDemo {
publicstatic void main(String[] args) {
//3创建自定义类对象
StopThreadst = new StopThread();
//4创建线程对象
Threadt1 = new Thread(st);
Threadt2 = new Thread(st);
//5设置为守护线程,必须在启动线程前完成
t1.setDaemon(true);
t2.setDaemon(true);
//如果自定义线程都是守护线程,那么程序执行完主线程后,JVM虚拟机就直接退出,不再执行自定义线程了。
//6启动线程
t1.start();
t2.start();
int num= 0;
while(true){
if(num++== 60) {
break;//退出死循环
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("mainover");//主线程执行完毕标志
}
}
输出结果:
main.......59
Thread-1....run
main.......60
Thread-0....run
main over //主线程结束
Thread-1....run
Thread-0....run
请按任意键继续. . .
由输出结果可知:当主线程结束时,守护线程也随之结束。
3、Join方法
简介:当A线程执行到了B线程的.join()方法时,A就会等待。等B线程都执行完,A才会执行。join可以用来临时加入线程执行。
public final void join()
测试案例5:
//自定义类
class Demo implements Runnable{
//重写run方法
public void run() {
for(int x=0; x<70; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
//测试类
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t1.join();//会抛出异常,t1抢到主线程的CPU执行权开始执行(此时主线程处于冻结状态),等线程t1执行完毕后其他线程才能继续执行。也就是说主线程要等到t1挂掉后他才能运行。
t2.start();
//t1.join();//当t1在此处加入线程时,主线程处于冻结状态,线程t1,t2处于就绪态,那么t1,t2两个线程在CPU的切换下轮流执行。当t1执行完毕,不管t2是否执行完毕,主线程已经“活过来了”,此时主线程和t2处于抢夺cpu的状态,这两个线程在CPU的切换下执行直到所有线程都结束为止。
//主线程
for(int x=0; x<80; x++) {
System.out.println("main....."+x);
}
System.out.println("over");
}
}
输出结果:略
4、Priority和yield方法
优先级表示抢夺CPU的频率。优先级从1-10,1级最低,10级最高,所有的线程的默认优先级都是5。
publicfinal void setPriority(int newPriority)//更改线程的优先级
publicstatic void yield()//暂停当前正在执行的线程对象,并执行其他线程。Yield:放弃
测试案例6:
//自定义类实现runnable接口
class Demo implements Runnable {
public void run() {
for(int x=0; x<70; x++) {
System.out.println(Thread.currentThread().toString()+"....."+x);
//Thread.yield();//临时释放CPU执行权,减缓线程的运行,让线程都有机会平均运行的效果。
}
}
}
//测试类
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
//当数据是固定时就定义成常量,当数据是共享时就定义成static
t1.setPriority(Thread.MAX_PRIORITY);//把t1设置为最高优先级
t2.start();
//主线程
for(int x=0; x<80; x++) {
//不操作
}
System.out.println("over");
}
}
四、匿名内部类方式使用多线程
方式1:
new Thread(){重写run方法...}.start();
方式2:
New Thread(new Runnable(){重写run方法...}).start();
测试案例7:
public
class ThreadDemo {
public
static void main(String[]
args) {
//匿名内部类,Thread类的子类
new Thread(){
//Thread类的匿名子类对象
public
void run() {
System.out.println("Thread匿名内部类对象");
};
}.start();
//匿名内部类方式,实现Runnable接口,父类引用指向子类对象
new Thread(new Runnable() {
@Override
public
void run() {
System.out.println("Runnable接口匿名内部类子类对象");
}
}).start();
}
}
五、线程组
5.1线程组简介:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。默认情况下,所有的线程都属于主线程组。从JDK1.0开始。
5.2 ThreadGroup构造方法:
publicThreadGroup(Stringname)//构造一个新线程组。新线程组的父线程组是目前正在运行线程的线程组
publicThreadGroup(ThreadGroup parent,Stringname)//创建一个新线程组。新线程组的父线程组是指定的线程组
5.3 ThreadGroup常用方法
publicfinal
StringgetName()//返回此线程组的名称
5.3Thread类有关线程组的构造方法:
public Thread(ThreadGroupgroup, String name)
public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group,Runnable target, String name)
//给线程设置分组。
5.4 Thread类有关线程组的常用方法
publicfinal ThreadGroup getThreadGroup()//返回该线程所属的线程组
5.5测试案例:
public
class ThreadDemo {
public
static void main(String[]
args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
//创建一个线程组
MyThreadGroupgroup =
new MyThreadGroup("javaEE");
//创建一个新的线程对象,并把该线程对象设置为javaEE组的成员
MyThread t3 = new MyThread(group,"se");
t3.start();
}
}
//线程类
public
class MyThread extends Thread {
public MyThread() {
super();
}
publicMyThread(ThreadGroupgroup, String
name) {
super(group,name);
}
public
void run() {
System.out.println("当前线程的名字是:" + getName());
//获取到线程组对象
ThreadGroup threadGroup =this.getThreadGroup();
//获取线程组的名字
String name =
threadGroup.getName();
System.out.println("当前线程对象所在的组名是: " +name);
}
}
//线程组类
public
class MyThreadGroup extends ThreadGroup {
publicMyThreadGroup(Stringname) {
super(name);
}
}
六、线程池
6.1简介:程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。
JDK5新增了一个Executors(执行者)工厂类来产生线程池。
6.2 Executors类的构造方法:无
6.3 Executors类的常用方法:
publicstatic ExecutorService newCachedThreadPool()//创建一个具有高效缓存功能的线程池对象
publicstatic ExecutorService newFixedThreadPool(int nThreads)//创建一个可重用的线程池,具有固定(Fixed)线程数的线程池,n为1时也可以创建单个线程对象的线程池
publicstatic ExecutorService newSingleThreadExecutor()//创建单个线程对象的线程池对象。
这些方法的返回值是ExecutorService(线程池)对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。
ExecutorService接口常用方法:(JDK1.5)
注意:ExecutorService直译为“执行者服务”在java中叫线程池。
Future<?>submit(Runnable task)//提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。(submit:提交)
<T>Future<T> submit(Callable<T> task)// 提交一个 Runnable任务用于执行,并返回一个表示该任务的 Future。
Future<V>接口简介(jdk1.5)
Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。计算完成后只能使用 get 方法来获取结果,如有必要,计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。
6.4 测试案例
//1、自定义类,实现runnable接口
public
class MyRunnable implements Runnable {
//2、重写run方法,线程体
public
void run() {
System.out.println("我是线程体");
//获取线程名字
System.out.println(Thread.currentThread().getName());
}
}
//测试类
public
class ThreadPool {
public
static void main(String[]
args) {
//3、用Executors类中的newFixedThreadPool()方法创建带有2个线程对象的线程池对象(用方法的返回值"创建"对象)。
ExecutorServiceservice = Executors.newFixedThreadPool(2);
//4、将线程体对象当做参数传递给ExecutorService接口中的submit()方法,来启动线程,执行现场体。
//submit()方法相当于Thread类中的start()方法.
service.submit(new MyRunnable());
service.submit(new MyRunnable());
}
}
输出结果:
我是线程体
我是线程体
pool-1-thread-2
pool-1-thread-1
七、java多线程实现方式3,实现Callable接口
1 简介:
通过线程池对象,实现Callable(随时可偿还的)接口。Callable接口类似于Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。从JDK1.5开始。
2构造方法:无
3 普通方法:
V call()//计算结果,如果无法计算结果,则抛出一个异常.相当于runnable接口中的run方法。
4 创建线程的步骤:
1) 自定义类实现Runnable接口
2) 重写call方法
3) 创建线程池对象
4) 实现线程池中的线程对象,来执行线程要执行的代码
5测试案例:
//1、自定义类实现Callable接口
public
class MyCallable implementsCallable{
//2、重写call方法,相当于Runnable接口中的run()方法
public Object call()throws Exception {
System.out.println("创建线程的第三种方法,通过线程池对象实现Callable接口");
System.out.println(Thread.currentThread().getName());
return
null;
}
}
//测试类
public
class ThreadTest {
public
static void main(String[]
args) {
//3、创建线程池对象
ExecutorServiceservice = Executors.newFixedThreadPool(2);
//4、实现线程池中的线程对象,来执行线程要执行的代码
service.submit(new MyCallable());
service.submit(new MyCallable());
}
}
输出结果:
由输出结果可知:程序一直处于等待状态。
八、定时器:
1 简介:定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能。
2 Timer类
一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。位于java.util包中。从JDK1.3开始。
Timer类构造方法:
public Timer()//创建一个新计时器
常用方法:
publicvoid schedule(TimerTask task, long delay) //在指定的时间到达后,执行TimerTask中的run方法
public void schedule(TimerTask task,longdelay,long period)//在指定的时间到达后,执行TimerTask中的run方法,并且以后每隔固定的时间重复执行
3 TimerTask类
是一个抽象类。由Timer 安排为一次执行或重复执行的任务,位于java.util包中,从JDK1.3开始。
TimerTask构造方法:
protected TimerTask()//创建一个新的计时器任务
TimerTask常用方法:
public abstract void run()//此计时器任务要执行的操作。
public boolean cancel()//取消此计时器任务。
备注:在android开发中Quartz是一个完全由java编写的开源调度框架。
4 测试案例:设置一个定时器,5秒钟后闹钟响起,以后每隔3秒响一次。
public
class TimerDemo {
public
static void main(String[]
args) {
//1、创建timer对象
Timer timer = new Timer();
//2、匿名方式创建TimerTask对象
TimerTask task =
new TimerTask() {
//3、重写run()方法,准备好定时器Timer要执行的内容(任务)
public
void run() {
System.out.println("除非你能在床上挣钱,否则就别赖在床上不起");
}
};
//4、执行任务
timer.schedule(task, 5000, 3000);
}
}
九、设计模式
1概述:
设计模式(Designpattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让带码更容易被他人理解、保证代码可靠性。
设计模式不是一种方法和技巧,而是一种思想。
设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想,尽可能的面向接口编程,实现低耦合,高内聚。
2设计模式分类:
创建型模式:简单工程模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式(6个)
行为型模式:模板方法模式,观察者模式,状态模式,职责链模式,命令模式,访问者模式,策略模式,备忘录模式,迭代器模式,解释器模式(10个)
结构型模式:外观模式,适配器模式,代理模式,装饰模式,桥接模式,组合模式,享元模式(7个)
备注:红色为实际编程中常用的设计模式。
3单例设计模式:
概述:在内存中一个类只能有一个实例对象。
分类:
饿汉式:创建步骤 1、构造方法私有,2、在本类中创建本类对象,3、对外提供公共访问方法,用来获取当前类对象。
懒汉式:创建步骤1、构造方法私有,2、在本类中创建本类的对象引用,而不是创建对象,3、对外提供公共访问方法,用来获取当前类对象,3.1如果是第一次访问方法,完成对象的创建,3.2如果不是第一次访问对象,返回创建好的对象。
测试案例1:创建饿汉式单例设计模式
//饿汉式
public
class Single {
//1、构造方法私有
private Single(){}
//2、在本类中,创建本类对象
private
static Single s =
new Single();
//3、对外提供公共访问方法,用来获取当前类对象
public
static SinglegetInstance(){
returns;
}
}
//测试类
public
class Test {
public
static void main(String[]
args) {
//
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1 ==s2);//判断对象引用s1、s2指向的地址是否相等
System.out.println(s1);
System.out.println(s2);
}
}
输出结果:
true
Single@659e0bfd
Single@659e0bfd
由输出结果可知,s1、s2指向堆中同一块内存地址。
测试案例2:创建懒汉式单例设计模式
//懒汉式
public
class Single2 {
//构造方法私有
private Single2(){}
//在本类中,创建本类对象的引用,而不创建对象
private
static Single2 s =
null;
//对外提供公共访问方法,用来获取当前类对象
public
synchronized static Single2getInstance(){
if (s ==null) {
//t1, t2
//如果是第一次访问方法:完成对象的创建
s =
new Single2();
}
//如果不是第一次访问方法,返回创建好的对象
returns;
}
}
//测试类
public
class Test2 {
public
static void main(String[]
args) {
Single2 s1 = Single2.getInstance();
Single2 s2 = Single2.getInstance();
System.out.println(s1 ==s2);
System.out.println(s1);
System.out.println(s2);
}
}
输出结果
true
Single2@659e0bfd
Single2@659e0bfd
由输出结果可知,s1、s2指向堆中同一块内存地址。
注意:在多线程的情况下,懒汉式的会有线程安全问题,饿汉式没有线程安全问题。开发的时候用饿汉式。
十、多线程常见问题
1多线程有几种实现方案,分别是哪几种?
答:3种,
方式一:继承Thread类,重写run方法
方式二:实现Runnable接口,实现run方法
方式三:通过线程池,实现Callable接口,实现call()方法。
2同步有几种方式,分别是什么?
答:3种
方式一:同步代码块,锁对象是任意的
方式二:同步函数,普通同步函数的锁对象是this,静态同步函数的锁是类名.class
方式三:Lock锁
当一个程序有多个线程操作同一个共享数据时,要求线程对象所使用的是同一把锁对象。
3 启动一个线程是run()还是start()?它们的区别?
答:启动一个线程是start()方法,
run()方法是线程要执行的操作,线程体
start()方法启动线程,告诉JVM调用run()方法。
4 sleep()和wait()方法的区别?
答:sleep()方法是让线程休眠指定的时间,时间到后自动醒来。在线程休眠的过程中不会释放锁对象,但会释放CPU执行权。
wait()方法是让线程处于等待状态,当设置指定的时间,时间到后会自动醒来,如果没有设置等待时间,则必须由notify()或notifyAll()方法来唤醒。在线程等待的过程中会释放CPU的执行权和锁对象。
5 为什么wait(),notify(),notifyAll()等方法都定义在Object类中
答:因为这些方法的调用,要使用当前线程中的锁对象来调用,而锁对象的类型是任意对象,所以,放在Object类中。
相关文章推荐
- 【JAVA】使用ZXing生成二维码
- java的事件监听器学习
- 【JAVA】使用ZXing生成嵌套图片的二维码
- 避免Java应用中NullPointerException的技巧和最佳实践
- hadoop2.6.0的eclipse插件编译和设置
- java多线程概念
- Struts2中Session的使用
- Minimum Size Subarray Sum 【leetCode】Java
- 浅析Spring事务传播行为和隔离级别
- java Data、String、Long三种日期类型之间的相互转换
- JDK 环境变量配置 -- Path classpath
- Spring3 MVC 注解
- MyEclipse2014安装jadeclipse插件
- eclipse有时候导入了包,但是还是有红线,找不到
- Java同步块
- 08、Spring_web.xml_DelegatingFilterProxy
- spring aop 最简单的例子。
- MyEclipse10.0 采用插件方式安装 SVN
- Java基础(极客)——25、Java集合类详解(补充)
- 插件GsonFormat快速实现JavaBean