建站程序的作用,asp模版网站如何做优化,深圳市宝安区怎么样,wordpress功能主题目录#xff1a;
线程安全 线程安全产生的原因线程的同步同步代码块同步方法Lock锁线程死锁 概述:产生条件:代码实践线程的状态线程通信线程池 线程使用存在的问题线程池的介绍线程池使用的大致流程线程池的好处Java提供好的线程池线程池处理Runnable任务线程池处理Callable任…目录
线程安全 线程安全产生的原因线程的同步同步代码块同步方法Lock锁线程死锁 概述:产生条件:代码实践线程的状态线程通信线程池 线程使用存在的问题线程池的介绍线程池使用的大致流程线程池的好处Java提供好的线程池线程池处理Runnable任务线程池处理Callable任务
1.线程安全
线程安全产生的原因 多个线程在对共享数据进行读改写的时候可能导致的数据错乱就是线程的安全问题了
package com.itheima.ticket_demo;/*电影院*/
public class Ticket implements Runnable {private int ticketCount 100; // 一共有一百张票Overridepublic void run() {while (true) {// 如果票的数量为0 , 那么停止买票if (ticketCount 0) {break;} else {// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() 卖出一张票,剩下 ticketCount 张);}}}
}package com.itheima.ticket_demo;/*1 定义一个类Ticket实现Runnable接口里面定义一个成员变量private int ticketCount 100;2 在Ticket类中重写run()方法实现卖票代码步骤如下A判断票数大于0就卖票并告知是哪个窗口卖的B票数要减1C卖光之后线程停止3 定义一个测试类TicketDemo里面有main方法代码步骤如下A创建Ticket类的对象B创建三个Thread类的对象把Ticket对象作为构造方法的参数并给出对应的窗口名称C启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket new Ticket();// 创建三个线程类对象Thread t1 new Thread(ticket);Thread t2 new Thread(ticket);Thread t3 new Thread(ticket);// 给三个线程命名t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);// 开启三个线程t1.start();t2.start();t3.start();}
}
注意 : 以上代码是有问题 , 接下来继续改进 因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码
package com.itheima.ticket_demo;/*电影院*/
public class Ticket implements Runnable {private int ticketCount 100; // 一共有一百张票Overridepublic void run() {while (true) {// 如果票的数量为0 , 那么停止买票if (ticketCount 0) {break;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() 卖出一张票,剩下 ticketCount 张);}}}
}package com.itheima.ticket_demo;/*1 定义一个类Ticket实现Runnable接口里面定义一个成员变量private int ticketCount 100;2 在Ticket类中重写run()方法实现卖票代码步骤如下A判断票数大于0就卖票并告知是哪个窗口卖的B票数要减1C卖光之后线程停止3 定义一个测试类TicketDemo里面有main方法代码步骤如下A创建Ticket类的对象B创建三个Thread类的对象把Ticket对象作为构造方法的参数并给出对应的窗口名称C启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket new Ticket();// 创建三个线程类对象Thread t1 new Thread(ticket);Thread t2 new Thread(ticket);Thread t3 new Thread(ticket);// 给三个线程命名t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);// 开启三个线程t1.start();t2.start();t3.start();}
} 通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题 问题出现的原因 : 多个线程在对共享数据进行读改写的时候可能导致的数据错乱就是线程的安全问题了
线程的同步
概述 : java允许多线程并发执行当多个线程同时操作一个可共享的资源变量时如数据的增删改查将会导致数据不准确相互之间产生冲突因此加入同步锁以避免在该线程没有完成操作之前被其他线程的调用从而保证该变量的唯一性和准确性
分类
同步代码块同步方法锁机制。Lock
同步代码块
同步代码块 : 锁住多条语句操作共享数据可以使用同步代码块实现第一部分 : 格式synchronized(任意对象) {多条语句操作共享数据的代码}第二部分 : 注意1 默认情况锁是打开的只要有一个线程进去执行代码了锁就会关闭2 当线程执行完出来了锁才会自动打开第三部分 : 同步的好处和弊端好处 : 解决了多线程的数据安全问题弊端 : 当线程很多时因为每个线程都会去判断同步上的锁这是很耗费资源的无形中会降低程序的运行效率
public class Ticket implements Runnable {private int ticketCount 100; // 一共有一百张票Overridepublic void run() {while (true) {synchronized (Ticket.class) {// 如果票的数量为0 , 那么停止买票if (ticketCount 0) {break;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() 卖出一张票,剩下 ticketCount 张);}}}}
} package com.itheima.synchronized_demo1;/*1 定义一个类Ticket实现Runnable接口里面定义一个成员变量private int ticketCount 100;2 在Ticket类中重写run()方法实现卖票代码步骤如下A判断票数大于0就卖票并告知是哪个窗口卖的B票数要减1C卖光之后线程停止3 定义一个测试类TicketDemo里面有main方法代码步骤如下A创建Ticket类的对象B创建三个Thread类的对象把Ticket对象作为构造方法的参数并给出对应的窗口名称C启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket new Ticket();// 创建三个线程类对象Thread t1 new Thread(ticket);Thread t2 new Thread(ticket);Thread t3 new Thread(ticket);// 给三个线程命名t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);// 开启三个线程t1.start();t2.start();t3.start();}
}
同步方法
同步方法就是把synchronized关键字加到方法上格式修饰符 synchronized 返回值类型 方法名(方法参数) { }同步代码块和同步方法的区别:1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码2 同步代码块可以指定锁对象,同步方法不能指定锁对象注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。1 对于非static方法,同步锁就是this。2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象
package com.itheima.synchronized_demo2;/*同步方法就是把synchronized关键字加到方法上格式修饰符 synchronized 返回值类型 方法名(方法参数) { }同步代码块和同步方法的区别:1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码2 同步代码块可以指定锁对象,同步方法不能指定锁对象注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。1 对于非static方法,同步锁就是this。2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象*/
public class Ticket implements Runnable {private int ticketCount 100; // 一共有一百张票Overridepublic void run() {while (true) {if (method()) {break;}}}private synchronized boolean method() {// 如果票的数量为0 , 那么停止买票if (ticketCount 0) {return true;} else {// 模拟出票的时间try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() 卖出一张票,剩下 ticketCount 张);return false;}}
}package com.itheima.synchronized_demo2;/*1 定义一个类Ticket实现Runnable接口里面定义一个成员变量private int ticketCount 100;2 在Ticket类中重写run()方法实现卖票代码步骤如下A判断票数大于0就卖票并告知是哪个窗口卖的B票数要减1C卖光之后线程停止3 定义一个测试类TicketDemo里面有main方法代码步骤如下A创建Ticket类的对象B创建三个Thread类的对象把Ticket对象作为构造方法的参数并给出对应的窗口名称C启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket new Ticket();// 创建三个线程类对象Thread t1 new Thread(ticket);Thread t2 new Thread(ticket);Thread t3 new Thread(ticket);// 给三个线程命名t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);// 开启三个线程t1.start();t2.start();t3.start();}
}
Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题但是我们并没有直接看到在哪里加上了锁在哪里释放了锁
为了更清晰的表达如何加锁和释放锁JDK5以后提供了一个新的锁对象LockLock中提供了获得锁和释放锁的方法void lock()获得锁void unlock()释放锁Lock是接口不能直接实例化这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法ReentrantLock()创建一个ReentrantLock的实例注意多个线程使用相同的Lock锁对象需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
package com.itheima.synchronized_demo3;import java.util.concurrent.locks.ReentrantLock;/*虽然我们可以理解同步代码块和同步方法的锁对象问题但是我们并没有直接看到在哪里加上了锁在哪里释放了锁为了更清晰的表达如何加锁和释放锁JDK5以后提供了一个新的锁对象LockLock中提供了获得锁和释放锁的方法void lock()获得锁void unlock()释放锁Lock是接口不能直接实例化这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法ReentrantLock()创建一个ReentrantLock的实例注意多个线程使用相同的Lock锁对象需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用*/
public class Ticket implements Runnable {private int ticketCount 100; // 一共有一百张票ReentrantLock lock new ReentrantLock();Overridepublic void run() {while (true) {try {lock.lock();// 加锁// 如果票的数量为0 , 那么停止买票if (ticketCount 0) {break;} else {// 模拟出票的时间Thread.sleep(100);// 有剩余的票 , 开始卖票ticketCount--;System.out.println(Thread.currentThread().getName() 卖出一张票,剩下 ticketCount 张);}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();// 释放锁}}}
} package com.itheima.synchronized_demo3;/*1 定义一个类Ticket实现Runnable接口里面定义一个成员变量private int ticketCount 100;2 在Ticket类中重写run()方法实现卖票代码步骤如下A判断票数大于0就卖票并告知是哪个窗口卖的B票数要减1C卖光之后线程停止3 定义一个测试类TicketDemo里面有main方法代码步骤如下A创建Ticket类的对象B创建三个Thread类的对象把Ticket对象作为构造方法的参数并给出对应的窗口名称C启动线程*/
public class TicketDemo {public static void main(String[] args) {// 创建任务类对象Ticket ticket new Ticket();// 创建三个线程类对象Thread t1 new Thread(ticket);Thread t2 new Thread(ticket);Thread t3 new Thread(ticket);// 给三个线程命名t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);// 开启三个线程t1.start();t2.start();t3.start();}
}
2.线程死锁
概述: 死锁是一种少见的而且难于调试的错误在两个线程对两个同步锁对象具有循环依赖时就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁除了重启没有其他办法的
产生条件: 多个线程 存在锁对象的循环依赖
代码实践
package com.itheima.deadlock_demo;/*死锁 :死锁是一种少见的而且难于调试的错误在两个线程对两个同步锁对象具有循环依赖时就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁除了重启没有其他办法的*/
public class DeadLockDemo {public static void main(String[] args) {String 筷子A 筷子A;String 筷子B 筷子B;new Thread(new Runnable() {Overridepublic void run() {while (true) {synchronized (筷子A) {System.out.println(小白拿到了筷子A ,等待筷子B....);synchronized (筷子B) {System.out.println(小白拿到了筷子A和筷子B , 开吃!!!!!);}}try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}, 小白).start();new Thread(new Runnable() {Overridepublic void run() {while (true) {synchronized (筷子B) {System.out.println(小黑拿到了筷子B ,等待筷子A....);synchronized (筷子A) {System.out.println(小黑拿到了筷子B和筷子A , 开吃!!!!!);}}try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}, 小黑).start();}
}
3.线程的状态 4.线程通信
线程间的通讯技术就是通过等待和唤醒机制来实现多个线程协同操作完成某一项任务例如经典的生产者和消费者案例。等待唤醒机制其实就是让线程进入等待状态或者让线程从等待状态中唤醒需要用到两种方法如下等待方法 : void wait() 让线程进入无限等待。void wait(long timeout) 让线程进入计时等待以上两个方法调用会导致当前线程释放掉锁资源。唤醒方法 : void notify() 唤醒在此对象监视器锁对象上等待的单个线程。void notifyAll() 唤醒在此对象监视器上等待的所有线程。以上两个方法调用不会导致当前线程释放掉锁资源注意 等待和唤醒的方法都要使用锁对象调用需要在同步代码块中调用)等待和唤醒方法应该使用相同的锁对象调用
package com.itheima.waitnotify_demo;/*1 线程进入无限等待注意进入无限等待需要使用锁在同步代码中调用wait方法*/
public class Test1 {public static void main(String[] args) {Object obj new Object(); // 作为锁对象new Thread(new Runnable() {Overridepublic void run() {synchronized (obj) {System.out.println(线程开始执行);System.out.println(线程进入无线等待....);try {obj.wait(); // 进入无线等待状态 , 并释放锁} catch (InterruptedException e) {e.printStackTrace();}System.out.println(无线等待被唤醒....);}}}).start();}
}
package com.itheima.waitnotify_demo;/*线程进入无限等待后被唤醒注意等待和唤醒是两个或多个线程之间实现的。进入无限等待的线程是不会自动唤醒只能通过其他线程来唤醒。*/
public class Test2 {public static void main(String[] args) {Object obj new Object(); // 作为锁对象new Thread(new Runnable() {Overridepublic void run() {synchronized (obj) {System.out.println(线程开始执行);System.out.println(线程进入无线等待....);try {obj.wait(); // 进入无线等待状态 , 并释放锁} catch (InterruptedException e) {e.printStackTrace();}System.out.println(无线等待被唤醒....);}}}).start();new Thread(new Runnable() {Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (obj) {obj.notify();// 随机唤醒此监视器中等待的线程 , 不会释放锁System.out.println(唤醒后 , 5秒钟后释放锁);try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}}// 释放锁}}).start();}
}
package com.itheima.waitnotify_demo;/*3 线程进入计时等待并唤醒注意进入计时等待的线程时间结束前可以被其他线程唤醒。时间结束后会自动唤醒*/
public class Test3 {public static void main(String[] args) {new Thread(new Runnable() {Overridepublic void run() {synchronized (Test3.class) {System.out.println(获取到锁 , 开始执行);try {System.out.println(进入计时等待...3秒);Test3.class.wait(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(自动唤醒.);}}}).start();}
}
生产者和消费者案例
package com.itheima.waitnotify_demo2;import sun.security.krb5.internal.crypto.Des;/*生产者步骤1判断桌子上是否有汉堡包如果有就等待如果没有才生产。2把汉堡包放在桌子上。3叫醒等待的消费者开吃*/
public class Cooker implements Runnable {Overridepublic void run() {while (true) {synchronized (Desk.lock) {if (Desk.count 0) {break;} else {if (Desk.flag) {// 桌子上有食物try {Desk.lock.wait();} catch (InterruptedException e) {e.printStackTrace();}} else {// 桌子上没有食物System.out.println(厨师生产了一个汉堡包...);Desk.flag true;Desk.lock.notify();}}}}}
} package com.itheima.waitnotify_demo2;import sun.security.krb5.internal.crypto.Des;/*消费者步骤1判断桌子上是否有汉堡包。2如果没有就等待。3如果有就开吃4吃完之后桌子上的汉堡包就没有了叫醒等待的生产者继续生产汉堡包的总数量减一*/
public class Foodie implements Runnable {Overridepublic void run() {while (true) {synchronized (Desk.lock) {if (Desk.count 0) {break;} else {if (Desk.flag) {// 桌子上有食物System.out.println(吃货吃了一个汉堡包...);Desk.count--; // 汉堡包的数量减少一个Desk.flag false;// 桌子上的食物被吃掉 , 值为falseDesk.lock.notify();} else {// 桌子上没有食物try {Desk.lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}
}package com.itheima.waitnotify_demo2;public class Test {public static void main(String[] args) {new Thread(new Foodie()).start();new Thread(new Cooker()).start();}
} 5.线程池
线程使用存在的问题 如果并发的线程数量很多并且每个线程都是执行一个时间很短的任务就结束了这样频繁创建线程就会大大降低系统的效率因为频繁创建线程和销毁线程需要时间。 如果大量线程在执行会涉及到线程间上下文的切换会极大的消耗CPU运算资源
线程池的介绍 其实就是一个容纳多个线程的容器其中的线程可以反复使用省去了频繁创建线程对象的操作无需反复创建线程而消耗过多资源。
线程池使用的大致流程 创建线程池指定线程开启的数量 提交任务给线程池线程池中的线程就会获取任务进行处理任务。 线程处理完任务不会销毁而是返回到线程池中等待下一个任务执行。 如果线程池中的所有线程都被占用提交的任务只能等待线程池中的线程处理完当前任
线程池的好处 降低资源消耗。减少了创建和销毁线程的次数每个工作线程都可以被重复利用可执行多个任务。 提高响应速度。当任务到达时任务可以不需要等待线程创建 , 就能立即执行。 提高线程的可管理性。可以根据系统的承受能力调整线程池中工作线线程的数目防止因为消耗过多的内存 (每个线程需要大约1MB内存线程开的越多消耗的内存也就越大最后死机)。
Java提供好的线程池 java.util.concurrent.ExecutorService 是线程池接口类型。使用时我们不需自己实现JDK已经帮我们实现好了 获取线程池我们使用工具类java.util.concurrent.Executors的静态方 public static ExecutorService newFixedThreadPool (int num) : 指定线程池最大线程池数量获取线程池 线程池ExecutorService的相关方法 T FutureT submit(CallableT task) Future? submit(Runnable task) 关闭线程池方法一般不使用关闭方法除非后期不用或者很长时间都不用就可以关闭 void shutdown() 启动一次顺序关闭执行以前提交的任务但不接受新任务
线程池处理Runnable任务
package com.itheima.threadpool_demo;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*1 需求 :使用线程池模拟游泳教练教学生游泳。游泳馆线程池内有3名教练线程游泳馆招收了5名学员学习游泳任务。2 实现步骤创建线程池指定3个线程定义学员类实现Runnable创建学员对象给线程池*/
public class Test1 {public static void main(String[] args) {// 创建指定线程的线程池ExecutorService threadPool Executors.newFixedThreadPool(3);// 提交任务threadPool.submit(new Student(小花));threadPool.submit(new Student(小红));threadPool.submit(new Student(小明));threadPool.submit(new Student(小亮));threadPool.submit(new Student(小白));threadPool.shutdown();// 关闭线程池}
}class Student implements Runnable {private String name;public Student(String name) {this.name name;}Overridepublic void run() {String coach Thread.currentThread().getName();System.out.println(coach 正在教 name 游泳...);try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(coach 教 name 游泳完毕.);}
}
线程池处理Callable任务
package com.itheima.threadpool_demo;import java.util.concurrent.*;/*需求: Callable任务处理使用步骤1 创建线程池2 定义Callable任务3 创建Callable任务提交任务给线程池4 获取执行结果T FutureT submit(CallableT task) : 提交Callable任务方法 返回值类型Future的作用就是为了获取任务执行的结果。Future是一个接口里面存在一个get方法用来获取值练一练使用线程池计算 从0~n的和并将结果返回*/
public class Test2 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建指定线程数量的线程池ExecutorService threadPool Executors.newFixedThreadPool(10);FutureInteger future threadPool.submit(new CalculateTask(100));Integer sum future.get();System.out.println(sum);}
}// 使用线程池计算 从0~n的和并将结果返回
class CalculateTask implements CallableInteger {private int num;public CalculateTask(int num) {this.num num;}Overridepublic Integer call() throws Exception {int sum 0;// 求和变量for (int i 0; i num; i) {sum i;}return sum;}
}
