网站建设过程有哪几个阶段,wordpress上传主题失败,网络科技公司是传销吗,佛山网站设计公司线程 线程(Thread)是一个程序内部的一条执行流程。 程序中如果只有一条执行流程#xff0c;那这个程序就是单线程的程序。
线程的常用方法及构造器#xff1a;
Thread提供的常用方法public void run()
线程的任务方法public void start()
启动线程public String getName()
…线程 线程(Thread)是一个程序内部的一条执行流程。 程序中如果只有一条执行流程那这个程序就是单线程的程序。
线程的常用方法及构造器
Thread提供的常用方法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)
让当前执行的线程休眠多少毫秒后再继续执行public final void join()...
让调用当前这个方法的线程先执行完Thread提供的常见构造器public Thread(String name)
可以为当前线程指定名称public Thread(Runnable target)
封装Runnable对象成为线程对象public Thread(Runnable target, String name)
封装Runnable对象成为线程对象并指定线程名称多线程 多线程是指从软硬件上实现的多条执行流程的技术多条线程由CPU负责调度执行。 创建线程的方式 多线程的创建方式一继承Thread类 操作步骤 ① 定义一个子类MyThread继承线程类java.lang.Thread重写run()方法 ② 创建MyThread类的对象 ③ 调用线程对象的start()方法启动线程启动后还是执行run方法的 方式一优缺点 优点编码简单 缺点线程类已经继承Thread无法继承其他类不利于功能的扩展。 注意事项 直接调用run方法会当成普通方法执行此时相当于还是单线程执行。 只有调用start方法才是启动一个新的线程执行。 不要把主线程任务放在启动子线程之前。 这样主线程是一直先跑完的相当于是一个单线程的效果了。
/*** 方式一继承Thread类*/
public class MyThread extends Thread{Overridepublic void run() {for (int i 1; i 20; i) {System.out.println(新的线程执行i);}}
}/*** 创建线程方式一继承Thread类* 1.创建一个继承Thread类的子类* 2.重写Thread类中的run方法将此线程要执行的代码写在run方法中* 3.创建Thread类的子类的对象调用start方法**/
public class ThreadDemo1 {public static void main(String[] args) {MyThread myThread new MyThread();myThread.start();// 启动线程启动后还是执行run方法 交替执行
// myThread.run();//单线程for (int i 1; i 20; i) {System.out.println(主线程执行i);}}} 多线程的创建方式二实现Runnable接口 操作步骤 ① 定义一个线程任务类MyRunnable实现Runnable接口重写run()方法 ② 创建MyRunnable任务对象 ③ 把MyRunnable任务对象交给Thread处理。 ④ 调用线程对象的start()方法启动线程 方式二的优缺点 优点任务类只是实现接口可以继续继承其他类、实现其他接口扩展性强。 缺点需要多一个Runnable对象。
/*** 方式二: 实现Runnable接口*/
public class MyRunnable implements Runnable {Overridepublic void run() {for (int i 1; i 20; i) {System.out.println(MyRunablei);}}
} public class RunnableDemo2 {public static void main(String[] args) {// 创建线程任务对象MyRunnable myRunnable new MyRunnable();// 创建线程Thread thread new Thread(myRunnable);// 启动线程thread.start();/*** 使用匿名内部类, 创建线程* 写法* ① 可以创建Runnable的匿名内部类对象。* ② 再交给Thread线程对象。* ③ 再调用线程对象的start()启动线程。*/new Thread(new Runnable(){Overridepublic void run() {for (int i 1; i 20; i) {System.out.println(匿名内部类1i);}}}).start();// 使用Lambda表达式 简化new Thread(()- {for (int i 1; i 20; i) {System.out.println(匿名内部类2i);}}).start();for (int i 1; i 20; i) {System.out.println(maini);}}} 线程的创建方式三实现Callable接口利用FutureTask类来实现 操作步骤 ① 创建任务对象 ➢ 定义一个类实现Callable接口重写call方法封装要做的事情和要返回的数据。 ➢ 把Callable类型的对象封装成FutureTask线程任务对象。 ② 把线程任务对象交给Thread对象。 ③调用Thread对象的start方法启动线程。 ④ 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。 线程创建方式三的优缺点 优点线程任务类只是实现接口可以继续继承类和实现接口扩展性强可以在线程执行完毕后去获取线程执行的结 果。 缺点编码复杂一点。
import java.util.concurrent.Callable;/*** 方式三实现Callable接口*/
public class MyCallable implements CallableString {Overridepublic String call() throws Exception {for (int i 1; i 20; i) {System.out.println(约吗i);}return null;}
} import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;/*** 创建线程的第三种方式实现Callable接口* 优点:* 线程任务类只是实现接口可以继续继承类和实现接口扩展性强* 可以在线程执行完毕后去获取线程执行的结果。**/
public class CallableDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建线程任务对象MyCallable myCallable new MyCallable();// 创建FutureTask对象, 构造方法中传递线程任务对象FutureTaskString ft new FutureTask(myCallable);// 创建线程对象, 构造方法中传递线程对象Thread thread new Thread(ft);// 启动线程thread.start();/**获取线程执行结果线程必须在启动之后才能获取到线程执行结果。get()方法会阻塞当前线程直到获取到线程执行结果。如果get()方法在获取到线程执行结果之前当前线程被中断那么会抛出InterruptedException异常。*/String s ft.get();System.out.println(s);for (int i 1; i 20; i) {System.out.println(吃瓜i);}}} 什么是线程安全问题 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题。
线程安全卖票模拟
public class Ticket implements Runnable{private int tivket100;Overridepublic void run() {while (true){if (tivket 0){break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}tivket--;System.out.println(Thread.currentThread().getName() 在卖票剩余 tivket 张票);}}}} 测试类
public class TicketDemo {public static void main(String[] args) {Ticket ticket new Ticket();Thread thread1 new Thread(ticket,Thread1);Thread thread2 new Thread(ticket,Thread2);Thread thread3 new Thread(ticket,Thread3);thread1.start();thread2.start();thread3.start();}
} 部分运行结果
Thread1在卖票剩余98张票
Thread2在卖票剩余98张票
Thread3在卖票剩余98张票
Thread1在卖票剩余95张票
Thread3在卖票剩余96张票
Thread2在卖票剩余96张票
Thread3在卖票剩余94张票
Thread1在卖票剩余94张票
Thread2在卖票剩余93张票
Thread3在卖票剩余92张票
......
Thread1在卖票剩余4张票
Thread3在卖票剩余3张票
Thread2在卖票剩余2张票
Thread1在卖票剩余1张票
Thread3在卖票剩余0张票
Thread2在卖票剩余-1张票
Thread1在卖票剩余-2张票
从结果可以看出有重复卖票还有票卖超了这就是线程安全问题。 解决线程安全问题可以通过线程同步来解决。
线程同步 线程同步的核心思想让多个线程先后依次访问共享资源这样就可以避免出现线程安全问题。 解决方案 一同步代码块 作用把访问共享资源的核心代码给上锁以此保证线程安全。
synchronized(同步锁) {//出现线程安全问题的代码}// 对于当前同时执行的线程来说同步锁必须是同一把同一个对象否则会出bug。锁对象的使用规范 建议使用共享资源作为锁对象对于实例方法建议使用this作为锁对象。 对于静态方法建议使用字节码类名.class对象作为锁对象。 二同步方法 作用把访问共享资源的核心方法给上锁以此保证线程安全。
修饰符synchronized 返回值类型 方法名称(形参列表)
{操作共享资源的代码
}
原理每次只能一个线程进入执行完毕以后自动解锁其他线程才可以进来执行 同步方法底层原理 同步方法其实底层也是有隐式锁对象的只是锁的范围是整个方法代码。 如果方法是实例方法同步方法默认用this作为的锁对象。 如果方法是静态方法同步方法默认用类名.class作为的锁对象。 同步代码块好还是同步方法好 范围上同步代码块锁的范围更小同步方法锁的范围更大 可读性同步方法更好 三Lock锁 Lock锁是JDK5开始提供的一个新的锁定操作通过它可以创建出锁对象进行加锁和解锁更灵活、更方便、更强大。 Lock是接口不能直接实例化可以采用它的实现类ReentrantLock来构建Lock锁对象。
public ReentrantLock() 获得Lock锁的实现类对象void lock() 获得锁void unlock() 释放锁线程池 线程池就是一个可以复用线程的技术。 不使用线程池用户每发起一个请求后台就需要创建一个新线程来处理下次新任务来了肯定又要创建新线程处理的 创 建新线程的开销是很大的并且请求过多时肯定会产生大量的线程出来这样会严重影响系统的性能。 创建线程池
方式一使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueueRunnable workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)//使用指定的初始化参数创建一个新的线程池对象// 创建线程池
ThreadPoolExecutor poolExecutor new ThreadPoolExecutor(3, // 线程池的核心线程数量10, // 线程池的最大线程数量60, // 临时线程存活时间TimeUnit.SECONDS, // 临时线程存活时间单位new ArrayBlockingQueue(20), // 任务队列Executors.defaultThreadFactory(), // 线程工厂new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
); 参数一corePoolSize : 指定线程池的核心线程的数量。 参数二maximumPoolSize指定线程池的最大线程数量。 参数三keepAliveTime 指定临时线程的存活时间。 正式工3 最大员工数5 临时工2 临时工空闲多久被开除 参数四unit指定临时线程存活的时间单位(秒、分、时、天 参数五workQueue指定线程池的任务队列。 客人排队的地方 参数六threadFactory指定线程池的线程工厂。 负责招聘员工的hr 参数七handler指定线程池的任务拒绝策略线程都在忙任务队列也满了的时候新任务来了该怎么处理 方式二使用Executors线程池的工具类调用方法返回不同特点的线程池对象。
poolExecutor.execute();
import java.util.List;
import java.util.concurrent.*;/*** void execute(Runnable command) 执行 Runnable 任务* FutureT submit(CallableT task) 执行 Callable 任务返回未来任务对象用于获取线程返回的结果* void shutdown() 等全部任务执行完毕后再关闭线程池* ListRunnable shutdownNow() 立刻关闭线程池停止正在执行的任务并返回队列中未执行的任*/
public class Demo2 {public static void main(String[] args) {// 创建线程池ThreadPoolExecutor poolExecutor new ThreadPoolExecutor(3,10,60,TimeUnit.HOURS,new ArrayBlockingQueue(20),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());for (int i 1; i 16; i) {/*** 创建线程* 新任务提交时发现核心线程都在忙任务队列也满了* 并且还可以创建临时线程此时才会创建临时线程** 核心线程和临时线程都在忙任务队列也满了(最大线程数10队列数20)* 新的任务过来的时候才会开始拒绝任务。**/// 创建线程, 执行Runnable任务poolExecutor.execute(new Student(小红i));// 创建线程, 执行Callable任务poolExecutor.execute(new FutureTask(new Student2(张三i)));}// 关闭线程池poolExecutor.shutdown();}}class Student implements Runnable{private String name;public Student(String name){this.namename;}Overridepublic void run() {System.out.println(Thread.currentThread().getName()在教:name学游泳);}
}class Student2 implements Callable {private String name;public Student2(String name){this.namename;}Overridepublic Object call() throws Exception {System.out.println(Thread.currentThread().getName()在教:name学游泳);return null;}
}任务拒绝策略:
ThreadPoolExecutor.AbortPolicy()
丢弃任务并抛出RejectedExecutionException异常。是默认的策略ThreadPoolExecutor. DiscardPolicy()
丢弃任务但是不抛出异常这是不推荐的做法ThreadPoolExecutor. DiscardOldestPolicy()
抛弃队列中等待最久的任务 然后把当前任务加入队列中ThreadPoolExecutor. CallerRunsPolicy()
由主线程负责调用任务的run()方法从而绕过线程池直接执行并发/并行: 并发的含义 :进程中的线程是由CPU负责调度执行的但CPU能同时处理线程的数量有限为了保证全部线程都能往前执行 CPU会轮询为系统的每个线程服务由于CPU切换的速度很快给我们的感觉这些线程在同时执行这就是并发。 并行的理解: 在同一个时刻上同时有多个线程在被CPU调度执行。 #学无止尽 #记录并分享我的学习日常
