文章目录
程序、进程、线程
- 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
- 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的
- 若一个进程同一时间并行执行多个线程，就是支持多线程的
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
- 多个线程操作共享的系统资源可能就会带来安全的隐患。
- 使用多线程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
线程的创建和使用
继承Thread类
- 创建一个继承于Thread类的子类
- 重写Thread类的run() -->将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()
- 启动当前线程
- 调用当前线程的run()
//例子:遍历10以内的所有偶数
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
//2.重写Thread类的run()
@Override
public void run() {
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start():1启动当前线程 2调用当前线程的run()
t1.start();
//问题一:我们不能通过直接调用run()的方式启动线程.
//t1.run();
//问题二:再启动一个线程,遍历10以内的偶数,不可以还让已经start()的新城区执行,会报错
//t1.start();
//我们需要重新创建一个线程的对象
MyThread t2 = new MyThread();
t2.start();
//如下操作仍然在main线程中执行的.
for(int i=0;i<100;i++){
if(i%2!=0){
System.out.println("*************main***********");
}
}
}
}
实现Runnable接口
- 创建一个实现Runnable接口的类
- 实现类去实现Runnable中的抽象方法:run()
- 创建实现类的对象
- 将对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象调用start()
//1.创建一个实现Runnable接口的类
class MThread implements Runnable {
//2.实现类去实现Runnable中的抽象方法:run()
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i%2==0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1=new Thread(mThread);
t1.setName("线程1");
//5.通过Thread类的对象调用start(): 1.启用线程 2.调用当前的run()-->调用了Runnable类型的target
t1.start();
//再启动一个线程,遍历100以内的偶数
Thread t2=new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
比较创建线程的两种方式
- 区别
- 继承Thread：线程代码存放Thread子类run方法中。
- 实现Runnable：线程代码存在接口的子类的run方法。
- 实现方式的好处
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
Thread类的有关方法
- void start(): 启动线程，并执行对象的run()方法
- run(): 线程在被调度时执行的操作
- getName(): 返回线程的名称
- setName(String name):设置该线程名称
- Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- yield():释放当前cpu的执行权
- join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
- sleep(long millis)：让当前线程"睡眠"指定的时间.在指定的毫秒时间内,当前线程是阻塞状态
线程的优先级
- 线程的优先级等级
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5
获取和设置当前线程的优先级
- getPriority() ：返回线程优先值
- setPriority(int newPriority) ：改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
线程的生命周期
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
线程的同步
Synchronized的使用方法
- Java对于多线程的安全问题提供了专业的解决方式：同步机制
- 方式一:同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
class Window1 implements Runnable{
private int ticket=100;
Object obj=new Object();
@Override
public void run() {
while (true){
synchronized (obj){
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 卖票,票号为:"+ticket--);
}
else{
break;
}
// try {
// Thread.sleep(10); // 添加微小延迟
// } catch (InterruptedException e) {
// Thread.currentThread().interrupt();
// return;
// }
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w=new Window1();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
- 方式二:同步方法
public synchronized void show (String name){
….
}
class Window3 implements Runnable{
private int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private synchronized void show(){//同步监视器:this
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 卖票,票号为:"+ticket--);
}
// else{
// break;
// }
}
}
public class WindowTest3{
public static void main(String[] args) {
Window3 w=new Window3();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
同步机制中的锁
- synchronized的锁
- 任意对象都可以作为同步锁。
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class
- 注意
- 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
class Window implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while(true){
try{
//2.调用锁定方法Lock()
lock.lock();
if (ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":售票,票号为"+ticket--);
}
else{
break;
}
}finally{
//3.调用解锁方法
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w=new Window();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。
线程的死锁问题
- 死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
- 解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
synchronized与Lock的异同
- 同:二者都可以解决线程安全问题
- 不同:synchronized机制在执行完相应的同步代码块以后,自动的释放同步监视器
Lock需要手动的启用同步(Lock()),同时,结束同步也需要手动的实现(unlock()) - 优先使用顺序:Lock->同步代码快–>同步方法
线程的通信
- 线程通信涉及到的三个方法:
- wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器.
- notify():一但执行此方法,就会唤醒wait的一个线程,如果有多个线程被wait,就唤醒优先级高的那个
- notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
- 说明
- wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中.
- wait(),notify(),notifyAll()三个方法的调用者必须是同步代码快或同步方法中的同步监视器,否则会出现IllegalMonitorStateException
- .wait(),notify(),notifyAll()三个方法中是定义在java.lang.Object类中.
- sleep() 和wait()的异同
- 相同点:一旦执行方法,都可以使当前的线程进入阻塞状态.
- 不同点:
1)两个方法声明的位置不一样:Thread类中声明sleep(),Object类中声明wait().
2)调用的要求不同:sleep()可以在任何需要的场景下调用.
wait()必须在同步代码快或同步方法中.
3)关于是否释放同步监视器:如果两个方法都是用它在同步代码快或同步方法中,
sleep()不会释放锁,wait()会释放锁
JDK5.0新增线程创建方式
创建线程的方式三:实现Callable接口
- 创建一个实现Callable的实现类
- 实现call方法,将此线程需要执行的操作声明在call()中
- 创建Callable接口实现类的对象
- 将此Callable接口实现类的对象作为传递到FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
- 获取Callable中call方法的返回值
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum=0;
for (int i=1;i<=100;i++){
if(i%2==0){
System.out.println(i);
sum+=i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread=new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask的对象
FutureTask futureTask=new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
Thread t1=new Thread(futureTask);
t1.start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum=futureTask.get();
System.out.println("总和为:"+sum);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
创建线程的方式四:使用线程池
- 线程池的创建
- 提供指定线程数量的线程池
- 执行指定的线程的操作,需要提供Runnable接口或Callable接口实现类的对象
- 关闭连接池
- 优势
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
- 线程池相关API
- JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
execute:执行任务/命令，没有返回值，一般用来执行Runnable
submit:执行任务，有返回值，一般又来执行Callable
shutdown() ：关闭连接池 - Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
class NumberThread implements Runnable{
@Override
public void run() {
for(int i=0;i<=100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i=0;i<=100;i++){
if(i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumberThread2 implements Callable {
@Override
public Object call() throws Exception {
for(int i=0;i<=100;i++){
if(i%5==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
return null;
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service=Executors.newFixedThreadPool(10);
//设置线程池的属性
System.out.println(service.getClass().getName());
//2.执行指定的线程的操作,需要提供Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//
service.submit(new NumberThread2());//适合使用于Callable
//3.关闭连接池
service.shutdown();//关闭
}
}
Callable接口的方式比实现Runnable接口方式对比
- call()可以有返回值
- call()可以抛出异常,被外面的操作捕获,获取异常的信息
- Callable是支持泛型的