- 相关概念
- Thread类的有关方法
- 线程的创建和使用
- 1.继承于Thread类
- 2.实现Runnable接口
- 3.实现Callable接口
- 4.使用线程池(重点)
- 线程的同步
- 1.同步代码块
- 2.同步方法
- 3.Lock锁(JDK5)
- 死锁
- 线程优先级
- 线程的生命周期
- 单例模式(线程安全的懒汉式)
- 线程的通信
程序——一段静态的代码,静态对象
进程——正在运行的程序,动态的过程,资源分配的单位,系统为每个进程分配不同的内存区域
线程——是一个进程细化内部的一条执行路径;一个进程同一时间并行执行多个线程,即支持多线程;
作为调度和执行的单位,拥有独立的运行栈和pc;多个线程共享同一个进程中的方法区和堆
分类:守护线程、用户线程 守护线程服务于用户线程
并行——多个CPU同时执行多个任务
并发——一个CPU同时执行多个任务
多线程的优点:①提高应用程序的相应 ②提高计算机CPU的利用率 ③改善程序结构
① void start() :1.启动当前线程 2.调用当前线程的run()
② run() : 重写此方法,声明此线程要执行的操作
③ String getName()
④ void setName(String Name)
⑤ static Thread currentThread() :返回执行当前代码的线程
⑥ static void yield() :释放当前CPU的执行权
⑦ join() :在线程a中调用线程b的join方法,则a进入阻塞状态直至b完全执行
⑧ static void sleep(long millis) :阻塞指定毫秒
⑨ stop() :deprecated 强制结束生命周期
⑩ boolean isAlive() :deprecated
①创建一个继承于Thread的子类
②重写Thread类的run() 【声明此线程要执行的操作】
③创建Thread类的子类的对象 【多个线程多次new】
④通过此对象调用start() 【1.启动当前线程 2.调用当前线程的run()】 【若只调用run(),没有启动线程】
例:
class MyThread1 extends Thread { @override }
MyThread1 t1 = new MyThread1();
t1.setName(“线程1”);
t1.start();//区分调用run()
⑤子类的对象只能调用一次start
⑥采用匿名子类匿名对象的方法
new Thread(){ @override }.start();
①创建一个实现了Runnable的类
②实现类去实现Runnable中的抽象方法run() 【声明此线程要执行的操作】
③创建实现类的对象【只new一次】
④将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象 【多个线程多次new】
⑤通过Thread类的对象调用start()
例:
class MyThread2 implements Runnable { @override }
MyThread2 myThread2 = new MyThread2();
Thread t2 = new Thread(myThread2);
t2.start();
⑥子类的对象只能调用一次start
⑦采用匿名子类匿名对象的方法
new Thread(new Runnable(){ @override }).start();
比较:方式1有单继承的局限性,方式2更适合处理多个线程共享数据的情况
Thread类本就实现Runnable接口
JDK5新增线程创建方法(jdk5.0)
3.实现Callable接口与Runnable相比:
①重写call()方法,可以抛出异常,可以有返回值,支持泛型的返回值;
②需要借助FutureTask类,比如获取返回结果
创建步骤:
①创建实现类 class A implements Callable{}
②重写方法 public Object call() throws Exception{} 【声明此线程要执行的操作】
③创建实现类A的对象 A a = new A();
④借助FutureTask类的构造器创建对象 FutureTask futureTask = new FutureTask(a);
⑤创建Thread的对象 Thread t1 = new Thread(futureTask);
⑥创建完成,可以调用Thread类的方法(start等)
⑦若需要,可以调用futureTask.get()可以返回实现类重写后call()的返回值
例:
class MyThread3 implements Callable { @override }
MyThread3 myThread3 = new MyThread3();
FutureTask futureTask = new FutureTask(myThread3);
Thread t3 = new Thread(futureTask); //还是借助Thread的构造器
t3.start();
Object o = futureTask.get();
好处:①提高响应速度 ②降低资源消耗 ③便于资源管理
说明:
ExecutorService: 线程池接口
ThreadPoolExecutor:实现ExecutorService接口的实现类
Executors:工具类 ,用于创建并返回不同类型的线程池
1.提供指定线程数的线程池
ExecutorService service = Executors.newFixedThreadPool(nThreads);
2.执行指定的线程的操作,需要提供一个实现Runnable或Callable的实现类的对象
service.execute( new Thread1() ); //适用于实现Runnable
service.submit( new Thread2());
3.关闭线程池
service.shutdown();
4.可以设置线程池的属性
service.getClass()
ThreadPoolExecutor service1 = (ThreadPoolExecutor)service; //要调用实现类的对象的方法
service1.setCorePoolSize();
5.开发应用待补充
解决多线程的安全问题
共享数据:多个线程共同操作的变量
关键字synchronized
synchronized (同步监视器){ //需要被同步的代码,即操作共享数据的代码 }
同步监视器:同步锁,可以是任一个类的对象。多个线程必须要用同一个锁
①用implements方式实现可以考虑用this(前提是当前类只new一次)
②继承Thread方式可以考虑用“类名.class”(反射),慎用this
如果操作共享数据的代码都声明在一个方法内,则将此方法声明为synchronized
非静态的同步方法:public synchrod void method(){ } //默认同步监视器:this
静态的同步方式:public static synchrod void method(){ } //默认同步监视器:“类名.class”【没有对象】
private ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.unlock();
Lock 和 synchronized 的区别
synchronized方式在执行完同步代码后自动释放同步监视器,而Lock需要手动启动同步"lock()“和结束同步"unlock()”,Lock方式在声明位置上更灵活
不同线程分别占用了对方需要的同步资源不放弃,都在等待对方放弃【互相拿了对方的锁】
不会出现异常和提示,所有线程都处于阻塞状态
同优先级线程先入先出,采用时间片策略
高优先级,采用抢占式策略,抢占CPU的执行权,但并不意味着只有高优先级线程执行完才到低优先级线程(概率)
MAX/MIN/NORM_PRIORITY = 10/1/5
getPriority()
setPriority(int newPriority)
新建—就绪—运行—阻塞—死亡
class Bank {
private Bank() {//提供私有的无参构造器
}
private static Bank instance = null;//实例化,但不初始化;若此时实例化则为饿汉式
public static Bank getInstance() {//也可以用synchronized方法 默认锁:Bank.class
if (instance == null) {//提高效率
synchronized (Bank.class) {//同步代码块
if (instance == null) {
instance = new Bank();
}
}
}
return instance;
}
}
线程的通信
有关方法:
wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
notify():一旦执行此方法,就会唤醒被wait的一个线程,有多个则只唤醒优先级高的一个
notifyAll():一旦执行此方法,就会唤醒所有被wait的所有线程
说明:
1.wait(),notify(),notifyAll()都必须使用在同步代码块或同步方法中【lock不可用】
2.上述3个方法的调用者必须是同步代码块或同步方法中的同步监视器
3.上述3个方法是定义在java.lang.Object中的
sleep()和wait()
相同:执行会使当前线程进入阻塞状态
不同:
①声明的位置不一样【sleep()在Thread、wait()在Object】
②调用的要求不一样【sleep()可以在任何需要的场景、wait()必须使用在同步代码块或同步方法中】
③若都使用在同步代码块或同步方法中,是否释放同步监视器【sleep()no、wait()yes】



