免费制作婚介网站,项目网站分析,手机网站怎样做,网页设计作品集展示1.多线程 1.1 线程#xff08;Thread#xff09;
线程时一个程序内部的一条执行流程#xff0c;java的main方法就是由一条默认的主线程执行 1.2 多线程 多线程是指从软硬件上实现的多条执行流程的技术#xff08;多条线程由CPU负责调度执行#xff09; 许多平台都离不开多…
1.多线程 1.1 线程Thread
线程时一个程序内部的一条执行流程java的main方法就是由一条默认的主线程执行 1.2 多线程 多线程是指从软硬件上实现的多条执行流程的技术多条线程由CPU负责调度执行 许多平台都离不开多线程因为多线程可以实现并发技术只有通过多线程才可能实现多人同时订票等功能一个人就代表着一个线程
2. 创建多线程
Java是通过java.lang.Thread类的对象来代表线程的 2.1 线程创建方式一继承Thread类 2.1.1 创建步骤 定义一个子类继承线程类java.lang.Thread重写run( )方法方法体交给另一个线程执行 创建子类对象 调用子类对象的start( )方法启动线程通过start( )方法启动cpu会自动分配线程执行run( )方法
//1.子类MyThread继承Thread类
public class MyThread extends Thread{//2.重写run方法run方法的方法体就是新的线程执行体Overridepublic void run() {for (int i 0; i 5; i) {System.out.println(MyThread执行 i);}}
}public class Test1 {//main方法默认就是由一个主线程负责执行public static void main(String[] args) {//3.创建一个子类对象即新的线程对象MyThread myThread new MyThread();//4.调用start方法启动新线程执行run方法myThread.start();//5.主线程中通过for循环执行主线程的执行体for (int i 0; i 5; i) {System.out.println(main线程执行 i);}}
}2.1.2 优缺点
优点编码简单
缺点java是单继承线程类已经继承了Thread类就无法继承其他类不利于功能的扩展 2.1.3 注意事项
启动线程必须调用start方法不能调用run方法。直接调用run方法会被当成普通方法执行cpu不会分配新的线程来执行run方法中的方法体相当于还是单线程。不能把主线程任务放在启动子线程之前否则只有主线程任务执行完才会开启新的线程没有意义还是相当于单线程
public class Test2 {public static void main(String[] args) {MyThread myThread new MyThread();//如果调用run方法那么就不是启动新的线程而是在主线程中调用run方法myThread.run();for (int i 0; i 5; i) {System.out.println(main线程执行 i);};}
}result
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行4
main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
由结果可以看出变成了单线程只有主线程负责执行public class Test2 {public static void main(String[] args) {MyThread myThread new MyThread();for (int i 0; i 5; i) {System.out.println(main线程执行 i);};//主程序的执行体在线程开启之前所以先执行主程序的执行体相当于单线程myThread.start();}
}main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行42.2 线程创建方式二实现Runnable接口
2.2.1 创建步骤
定义一个线程任务类实现Runnable接口重写run( )方法创建任务对象将任务对象封装成Thread( )对象调用Thread线程对象的start( )方法启动线程
//1.创建一个实现了Runnable接口的类
public class MyRunnable implements Runnable{//2.实现类去实现Runnable中的抽象方法run()Overridepublic void run() {for (int i 0; i 5; i) {System.out.println(子线程执行》 i);}}
}public class Test1 {public static void main(String[] args) {//3.创建一个任务对象Runnable myRunnable new MyRunnable();//4.将任务对象封装成一个线程对象并调用start方法new Thread(myRunnable).start();for (int i 0; i 5; i) {System.out.println(main线程执行 i);}}
}result
子线程执行》0
main线程执行0
子线程执行》1
main线程执行1
子线程执行》2
main线程执行2
main线程执行3
main线程执行4
子线程执行》3
子线程执行》42.2.2 优缺点
优点任务类只是实现接口可以继续继承其他类、实现其他接口扩展性强
缺点需要多创建一个Runnable对象
2.2.3 使用匿名内部类改进代码
public class Test2 {public static void main(String[] args) {//使用匿名内部类的方式创建线程new Thread(new Runnable(){Overridepublic void run() {for (int i 0; i 3; i) {System.out.println(子线程1执行 i);}}}).start();//使用lambda表达式创建线程new Thread(() -{for (int i 0; i 3; i) {System.out.println(子线程2执行 i);}}).start();for (int i 0; i 3; i) {System.out.println(main线程执行 i);}}
}2.3 线程创建方式三实现Callable接口
2.3.1 实现步骤
创建任务对象 定义一个子类实现Callable接口重写call方法封装方法体和待返回数据 将Callable类型的对象封装成FutherTask线程任务对象将FutherTask线程任务对象交给Thread对象封装调用Thread线程对象的start( )方法启动线程线程执行完毕后通过FutherTask对象的get( )方法获取线程任务执行的结果 //1.创建一个实现Callable接口的实现类
public class MyCallable implements CallableDouble {private int n;public MyCallable(int n) {this.n n;}//2.重写call方法call方法的方法体就是新的线程执行体Overridepublic Double call() throws Exception {double sum 0;for (int i 1; i n; i) {sum i;}return sum;}
}public class Test {public static void main(String[] args) throws Exception {//3.创建一个子类对象CallableDouble myCallable new MyCallable(100);//4.创建一个FutureTask对象将myCallable对象作为构造参数传入FutureTaskDouble futureTask new FutureTask(myCallable);//5.创建一个Thread对象并将FutureTask对象作为构造参数传入new Thread(futureTask).start();//创建第二个线程FutureTaskDouble futureTask2 new FutureTask(new MyCallable(200));new Thread(futureTask2).start();//6.通过FutureTask对象的get方法获取call方法的返回值//如果call方法没有执行完毕get方法会阻塞等待Double v futureTask.get();System.out.println(v);Double v2 futureTask2.get();System.out.println(v2);}
}2.3.2 优缺点
优点
线程任务类只是实现接口可以继续继承类和实现接口扩展性强可以在线程执行完毕后去获取线程执行的结果
缺点编码比较复杂 3.线程常用方法
方法说明public void run( )线程中要执行的方法public void start( )启动线程public String getName( )获取当前线程的名称线程名称默认是Thread-索引public void setName( String name )修改线程的名称public static Thread currentThread( )获取当前执行的线程对象public static void sleep( long time )让当前执行的线程休眠多少毫秒1000毫秒1秒public final void join( )让调用当前这个方法的线程先执行完再让其他线程执行
4. 线程安全问题
4.1 线程安全问题出现的原因
存在多个线程在同时执行同时访问一个共享资源存在修改该共享资源 5. 线程同步解决线程安全问题
5.1 认识线程同步
解决线程安全问题的方案
5.1.1 线程同步的思想
让多个线程实现先后依次访问共享资源这样就解决了安全问题 5.1.2 线程同步的常见方案
加锁每次只允许一个线程加锁加锁后才能进入访问访问完毕后自动解锁然后其他线程才能再加锁进来
同步代码块同步方法Lock锁
5.2 三种加锁方式
5.2.1 同步代码块
作用把访问共享资源的核心代码块上锁以此保证线程安全 原理每次只允许一个线程加锁后进入执行完毕后自动解锁其他线程才可以进来执行
注意事项对于当前同时执行的线程来说同步锁必须是同一把同一个对象否则会出bug因为对于不同的线程需要识别同步锁同步锁一致才会让一个线程加锁否则起不到加锁的作用。
锁对象的使用规范使用共享资源作为锁对象
对于实例方法建议使用this关键字作为锁对象
//修改4.2.1的程序中Account类中的drawMoney( )方法其余部分代码不变
//快捷键ctrlalttpublic void drawMoney(double drawMoney){String name Thread.currentThread().getName();//同步代码块synchronized (this) {if (money drawMoney){System.out.println(name 取钱成功吐出钞票 drawMoney);money - drawMoney;System.out.println(name 取钱后的余额为 money);}else {System.out.println(name 取钱失败余额不足);}}}
/*小明取钱成功吐出钞票100000.0小明取钱后的余额为0.0小红取钱失败余额不足*/2.对于静态方法建议使用字节码类名.class)对象作为锁对象 //示例public static void test(){//同步代码块synchronized (Account.class) {}}5.2.2 同步方法
作用把访问共享资源的核心方法给上锁以此保证线程安全 底层原理与同步代码块一致只是同步方法锁的范围更大
同步方法其实底层也是有隐式锁对象的只是锁的范围是整个方法代码如果方法是实例方法同步方法默认用this作为锁对象如果方法是静态方法同步方法默认用类名.clss作为锁对象
//修改4.2.1的程序中Account类中的drawMoney( )方法其余部分代码不变
//使用synchronized修饰方法同步方法public synchronized void drawMoney(double drawMoney){String name Thread.currentThread().getName();//同步代码块if (money drawMoney){System.out.println(name 取钱成功吐出钞票 drawMoney);money - drawMoney;System.out.println(name 取钱后的余额为 money);}else {System.out.println(name 取钱失败余额不足);}}
/*小明取钱成功吐出钞票100000.0小明取钱后的余额为0.0小红取钱失败余额不足*/5.2.3 Lock锁
Lock锁是JDK5开始提供的一个新的锁定操作通过它可以创建出锁对象进行加锁和解锁更灵活、更方便、更强大。Lock是接口不能直接实例化可以采用它的实现类ReentrantLock来构建Lock锁对象。
//修改4.2.1的程序中Account类中的drawMoney( )方法其余部分代码不变//创建锁对象private final Lock lock new ReentrantLock();public void drawMoney(double drawMoney){String name Thread.currentThread().getName();//使用try\cathc\finally代码块来确保锁一定会被释放,//否则一旦代码块中出现异常锁就不会被释放try {//加锁lock.lock();if (money drawMoney){System.out.println(name 取钱成功吐出钞票 drawMoney);money - drawMoney;System.out.println(name 取钱后的余额为 money);}else {System.out.println(name 取钱失败余额不足);}} catch (Exception e) {throw new RuntimeException(e);} finally {//释放锁lock.unlock();}}
/*小明取钱成功吐出钞票100000.0小明取钱后的余额为0.0小红取钱失败余额不足*/6. 线程通信了解
线程通信
当多个线程共同操作共享的资源时线程间通过某种方式互相告知自己的状态以相互协调并避免无效的资源争夺线程通讯的前提是必须线程安全
线程通信的常见模型生产者与消费者模型 生产者线程负责生产数据 消费者线程负责消费生产者生产的数据。 Object类提供的方法说明void wait( )让当前线程等待并释放所占锁直到另一个线程调用notify( )方法或notifyA11( )方法void notify( )唤醒正在等待的单个线程void notifyAll( )唤醒正在等待的所有线程
public class Desk {private ListString listnew ArrayList();public synchronized void put(){try {String name Thread.currentThread().getName();if(list.isEmpty()){list.add(name 做的包子);System.out.println(name 做的包子);Thread.sleep(1000);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}public synchronized void get(){try {String name Thread.currentThread().getName();if(!list.isEmpty()){list.clear();System.out.println(name 吃了包子);Thread.sleep(100);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}}public class Test {public static void main(String[] args) {Desk desk new Desk(); //创建桌子对象//创建厨师线程new Thread(()-{while (true) {desk.put();}}, 厨师1).start();new Thread(()-{while (true) {desk.put();}}, 厨师2).start();new Thread(()-{while (true) {desk.put();}}, 厨师3).start();//创建吃货线程new Thread(()-{while (true) {desk.get();}}, 吃货1).start();new Thread(()-{while (true) {desk.get();}}, 吃货2).start();}
}7. 线程池
7.1 认识线程池
7.1.1 什么是线程池
线程池就是一个可以复用线程的技术
7.1.2 不使用线程池的问题
用户每发起一个请求后台就需要创建一个新线程来处理下次新任务来了肯定又要创建新线程处理的而创建新线程的开销是很大的并且请求过多时肯定会产生大量的线程出来这样会严重影响系统的性能。
7.1.3 线程池的工作原理
如果线程池中有三个工作线程则每个线程都会处理任务队列中的一个任务当某个线程处理完一个任务后该线程会继续处理任务队列中的其他任务依次类推 7.2 创建线程池
JDK5.0起提供了代表线程池的接口ExecutorService
7.1.1 创建线程池对象的方式一推荐使用
使用实现了ExecutorService接口的实现类ThreadPoolExecutor创建线程池对象
ThreadPoolExecutor构造器
//格式
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueueRunnable workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)//实例
public class Test{public static void main(String[] args) {// 创建线程池方式一/*线程池中有三个核心线程线程池中有五个最大线程线程池中有5-32个临时线程临时线程的存活时间为8秒线程池中有4个任务队列拒绝策略为抛出异常并丢弃任务*/new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());}
}参数一corePoolSize指定线程池的核心线程的数量。相当于饭店的固定服务员的数量参数二maximumPoolSize指定线程池的最大线程数量。相当于饭店的固定服务员和临时员工的数量参数三keepAliveTime指定临时线程的存活时间。相当于临时员工可以干多久参数四unit指定临时线程存活的时间单位秒、分、时、天参数五workQueue指定线程池的任务队列。相当于待招待的客人的数量参数六threadFactory指定线程池的线程工厂。相当于负责招聘服务员的hr参数七handler指定线程池的任务拒绝策略线程都在忙任务队列也满了的时候新任务来了该怎么处理相当于饭店的临时工和固定服务员仍然忙不过来时应该如果对待新来的客人
任务拒绝策略说明ThreadPoolExecutor.AbortPolicy丢弃任务并抛出RejectedExecutionException异常。默认策略ThreadPoolExecutor.DiscardPolicy丢弃任务但是不抛出异常不推荐ThreadPoolExecutor.DiscardOldestPolicy抛弃队列中等待最久的任务然后把当前任务加入队列中ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的run( )方法从而绕过线程池直接执行
//创建Runnable任务类
public class MyRunnable implements Runnable{Overridepublic void run() {System.out.println(Thread.currentThread().getName() 线程被调用了);try {//让线程睡眠一会从而便于模拟并发环境Thread.sleep(Integer.MAX_VALUE);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}public class Test{public static void main(String[] args) {// 创建线程池ExecutorService pool new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());// 创建Runnable任务实例对象Runnable target new MyRunnable();//下面的三个任务被三个核心线程处理不占用任务队列中的空间pool.execute(target);//该方法会在线程池中自动创建一个新线程自动处理任务前提是线程池中有空闲线程pool.execute(target);pool.execute(target);//下面的四个任务进入任务队列等待处理pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);//当任务队列满了并且核心线程全部被占用会创建临时线程处理任务//但是只能创建两个临时线程因为最大线程数为5//下面的两个任务会被临时线程处理pool.execute(target);pool.execute(target);
// 下面的两个任务因为临时线程已经达到最大线程数所以会根据拒绝策略进行处理pool.execute(target);}
}
/*
结果见下图此时由于三个核心线程被占用四个任务也在任务队列中等待处理两个临时线程也被占用所以会根据拒绝策略进行任务处理*/7.1.2 创建线程池对象的方式二不推荐使用
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
Executors是一个线程池工具类提供了许多静态方法用于返回不同特点的线程池对象 方法名称说明public static ExecutorService newFixedThreadPool(int nThreads)创建固定线程数量的线程池如果某个线程因为执行异常而结束那么线程池会补充一个新线程替代它。public static ExecutorService newSingleThreadExecutor( )创建只有一个线程的线程池对象如果该线程出现异常而结束那么线程池会补充一个新线程。public static ExecutorService newCachedThreadPool( )线程数量随着任务增加而增加如果线程任务执行完并且空闲了6s则会被回收掉。public static ScheduledExecutorService newScheduledThreadPool(int corePoolsize)创建一个线程池可以实现在给定的延迟后运行任务或者定期执行任务。 这些方法的底层都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象
缺点大型并发系统环境中使用Executors?如果不注意可能会出现系统风险 FixedThreadPool和SingleThreadPool 允许的请求队列长度为Integer.MAX VALUE,可能会堆积大量的请求从而导致OOM(内存溢出)。 CachedThreadPool 允许的创建线程数量为Integer.MAX VALUE,可能会创建大量的线程从而导致OOM(内存溢出)。
使用线程池处理任务 ExecutorService的常用方法说明void execute(Runnable command)执行Runnable任务FutureT submit( CallableT task)执行Cal1able任务返回未来任务对象用于获取线程返回的结果void shutdown( )等全部任务执行完毕后再关闭线程池ListRunnable shutdownNow( )立刻关闭线程池停止正在执行的任务并返回队列中未执行的任务
注意一般不会关闭线程池如果实在需要关闭则使用void shutdown( )方法关闭 //1.创建一个实现Callable接口的实现类
public class MyCallable implements CallableDouble {private int n;public MyCallable(int n) {this.n n;}//2.重写call方法call方法的方法体就是新的线程执行体Overridepublic Double call() throws Exception {double sum 0;for (int i 1; i n; i) {sum i;}return sum;}
}public class Test3 {public static void main(String[] args) throws Exception{//创建线程池ExecutorService pool Executors.newFixedThreadPool(3);//创建Callable任务对象CallableDouble c1 new MyCallable(100);CallableDouble c2 new MyCallable(200);CallableDouble c3 new MyCallable(300);//执行任务并获取Future对象FutureDouble s1 pool.submit(c1);FutureDouble s2 pool.submit(c2);FutureDouble s3 pool.submit(c3);//输出结果System.out.println(s1.get());System.out.println(s2.get());System.out.println(s3.get());}
}8. 并发、并行、线程的生命周期
8.1 并发与并行
8.1.1 进程
正在运行的程序软件就是一个独立的进程。线程是属于进程的一个进程中可以同时运行很多个线程。进程中的多个线程其实并发和并行执行的。 8.1.2 并发
进程中的线程是由CPU负责调度执行的但CPU能同时处理线程的数量有限为了保证全部线程都能往前执行CPU会轮询为系统的每个线程服务由于CPU切换的速度很快给我们的感觉这些线程在同时执行这就是并发。
8.1.3 并行
在同一个时刻上同时有多个线程在被CPU调度执行。 8.2.1 Java线程的状态
Java定义了六种状态定义在Thread类的内部枚举类中 public enum State {NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;}线程状态说明NEW(新建)线程刚被创建但是并未启动Runnable(可运行)线程已经调用了start( ),等待CPU调度Blocked(锁阻塞)线程在执行的时候未竞争到锁对象则该线程进入Blocked状态Waiting(无限等待)一个线程进入Waiting状态另一个线程调用notify或者notifyAll方法才能够唤醒Timed Waiting(计时等待)同waiting状态有几个方法(sleep,wait)有超时参数调用他们将进入Timed Waiting状态。Teminated(被终止)因为run方法正常退出而死亡或者因为没有捕获的异常终止了run方法而死亡。
