传奇手游新开网站,重庆妇科排名前十的医院,如何对网站ftp进行上传,电子商务运营平台设计多线程
一#xff0c;什么是线程#xff1f;
程序#xff1a;为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码进程#xff1a;程序的一次执行过程。 正在运行的一个程序#xff0c;进程作为资源分配的单位#xff0c;在内存中会为每个进程分配不同的…多线程
一什么是线程
程序为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码进程程序的一次执行过程。 正在运行的一个程序进程作为资源分配的单位在内存中会为每个进程分配不同的内存区域。 进程是动态的是一个动的过程 进程的生命周期 : 有它自身的产生、存在和消亡的过程
线程是进程的进一步细化 是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程就是支持多线程的。 1.并行和并发
并行多个CPU同时执行多个任务 并发一个CPU“同时”执行多个任务采用时间片切换 二创建线程的三种方式 1继承Thread类
这个run方法不能直接调用直接调用就会被当做一个普通方法要用 . start() 启动线程。开辟道路的代码必须在前面 入门例子
//运行的类
public static void main(String[] args) {/* DomeThread dt new DomeThread();dt.start();*/new DomeThread().start();//开了一条新的路for (int i 0; i 100; i) {System.out.println(main() i);}}//穿插运行
}//准备
public class DomeThread extends Thread {//继承线程类 重写run()Overridepublic void run() {//另外一条道的执行代码show();}public void show() {for (int i 0; i 100; i) {System.out.println(DomeThread_show() i);}}
} 三个窗口售卖火车票----三种方式的例题也是线程安全问题的例题
//运行/*** 用继承方式的并行售票** param args*/public static void main2(String[] args) {//main方法---主线程//假设有三个窗口同时买票//没有构造方法命名会报错TicketThread tt1 new TicketThread(窗口1);//命名方法1TicketThread tt2 new TicketThread();tt2.setName(窗口2);//命名方法2TicketThread tt3 new TicketThread(窗口3);tt1.start();tt2.start();tt3.start();}//准备public class TicketThread extends Thread{static int count10;//静态--有一个对象对他进行改变其他对象再使用时就是修改过的Overridepublic void run() {while (count0) {count--;System.out.println(this.getName()卖出一张票还剩count张);}}public TicketThread() {}public TicketThread(String name) {super(name);}
}缺点
没有返回值不能抛出异常 接 三1------同步代码块 重写 run() Overridepublic void run() {for (int i 0; i 100; i) {synchronized (TicketThread.class) {//同步代码块 同步关键字锁子if (count 0) {count--;System.out.println(this.getName() 卖出一张票还剩 count 张);}}}}
//TicketThread.class 或者 this.getClass 2实现Runnable接口
Thread类实现了Runnable接口
//运行 public static void main3(String[] args) {TicketRunnable tr new TicketRunnable();Thread thread1 new Thread(tr, 窗口1);Thread thread2 new Thread(tr, 窗口2);Thread thread3 new Thread(tr, 窗口2);thread1.start();thread2.start();thread3.start();}
//准备public class TicketRunnable implements Runnable {int count 10;Overridepublic void run() {while (count 0) {count--;System.out.println(Thread.currentThread().getName() 卖出一张票还剩 count 张);}//Thread.currentThread().getName()---获得正在运行的线程的名字}}缺点
没有返回值不能抛出异常 接 三2----- 同步方法 重写run() , 新增一个synchronized同步方法 package thread;public class TicketRunnable implements Runnable {int count 10;Overridepublic void run() {for (int i 0; i 100; i) {buyTicket();}}public synchronized void buyTicket(){//默认锁 this对象if (count 0) {count--;System.out.println(Thread.currentThread().getName() 卖出一张票还剩 count 张);}}
}补充---休眠 Overridepublic void run() {for (int i 0; i 100; i) {buyTicket();//休眠如果运行时一直是一个窗口可以用这个try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}} 接 三3----Lock锁 重写run() , 定义锁 package thread;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class TicketRunnable implements Runnable {int count 10;Lock locknew ReentrantLock(); //多态 接口实现类 可以使用不同的实现类Overridepublic void run() {for (int i 0; i 100; i) {lock.lock();try {if (count 0) {count--;System.out.println(Thread.currentThread().getName() 卖出一张票还剩 count 张);}Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}finally {lock.unlock();}}}}3实现Callable接口 好处
有返回值 能抛出异常 缺点
线程创建比较麻烦
//运行
/*** 实现Callable接口的并行售票*/public static void main(String[] args) {TicketCall tcnew TicketCall();FutureTask ftnew FutureTask(tc);Thread t1new Thread(ft,窗口1);//存在默认名如果你不命名程序会显示Thread-0FutureTask ft1new FutureTask(tc);Thread t2new Thread(ft1,窗口2);FutureTask ft2new FutureTask(tc);Thread t3new Thread(ft2,窗口3);t1.start();t2.start();t3.start();//获取线程得到的返回值Object obj ft.get();System.out.println(obj);}//准备package thread;import java.util.concurrent.Callable;public class TicketCall implements Callable {int count 10;Overridepublic Object call() throws Exception {while (count 0) {count--;System.out.println(Thread.currentThread().getName() 卖出一张票还剩 count 张);}//Thread.currentThread().getName()---获得正在运行的线程的名字return null;}
}补充 实现Callable接口可以不带泛型如果不带泛型那么call方式的返回值就是Object类型 public class TicketCall implements CallableInteger { 如果带泛型那么call的返回值就是泛型对应的类型从call方法看到方法有返回值可以跑出异常 4线程的生命周期 四线程的常用方法
start() : 启动当前线程表面上调用start方法实际在调用线程里面的run方法 【例题中有】run() : 线程类 继承 Thread类 或者 实现Runnable接口的时候都要重新实现这个run方法run方法里面是线程要执行的内容 【例题中有】currentThread :Thread类中一个静态方法获取当前正在执行的线程 【Runnable例中】setName: 设置线程名字 【Thread例中】getName 读取线程名字 【例题中有】通过调用interrupt()方法来中断其阻塞状态设置优先级
同优先级别的线程采取的策略就是先到先服务使用时间片策略如果优先级别高被CPU调度的概率就高级别1-10 默认的级别为5线程的优先级是在创建线程时设置的在创建线程后的任何时候都可以重新设置
//运行
class Test{//这是main方法程序的入口public static void main(String[] args) {//创建两个子线程让这两个子线程争抢资源TestThread01 t1 new TestThread01();t1.setPriority(10);//优先级别高t1.start();TestThread02 t2 new TestThread02();t2.setPriority(1);//优先级别低t2.start();}
}//准备
public class TestThread01 extends Thread {Overridepublic void run() {for (int i 1; i 10; i) {System.out.println(i);}}
}
-----------------------------------------------------------
class TestThread02 extends Thread{Overridepublic void run() {for (int i 20; i 30 ; i) {System.out.println(i);}}
} join() : 当一个线程调用了join方法这个线程就会先被执行它执行结束以后才可以去执行其余的线程。 注意必须先start再join才有效。
//测试
class Test{//这是main方法程序的入口public static void main(String[] args) throws InterruptedException {for (int i 1; i 100 ; i) {System.out.println(main-----i);if(i 6){//创建子线程TestThread tt new TestThread(子线程);tt.start();tt.join();//“半路杀出个程咬金”}}}
}//准备
public class TestThread extends Thread {public TestThread(String name){super(name);}Overridepublic void run() {for (int i 1; i 10 ; i) {System.out.println(this.getName()----i);}}
}
sleep : 人为的制造阻塞事件
public class Test01 {//这是main方法程序的入口public static void main(String[] args) {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(00000000000000);}
} 案例完成秒表功能 public class Test02 {//这是main方法程序的入口public static void main(String[] args) {//2.定义一个时间格式DateFormat df new SimpleDateFormat(HH:mm:ss);while(true){//1.获取当前时间Date d new Date();//3.按照上面定义的格式将Date类型转为指定格式的字符串System.out.println(df.format(d));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
} setDaemon 设置伴随线程
将子线程设置为主线程的伴随线程主线程停止的时候子线程也不要继续执行了案例皇上 --》驾崩 ---》妃子陪葬 【将指定的线程设置成后台线程】
//运行
class Test{//这是main方法程序的入口public static void main(String[] args) {//创建并启动子线程TestThread tt new TestThread();tt.setDaemon(true);//设置伴随线程 注意先设置再启动tt.start();//主线程中还要输出1-10的数字for (int i 1; i 10 ; i) {System.out.println(main---i);}}
}//准备
public class TestThread extends Thread {Overridepublic void run() {for (int i 1; i 1000 ; i) {System.out.println(子线程----i);}}
} yield方法----的作用是让当前线程放弃CPU时间片进入和可运行状态与其他等待的可运行状态线程竞争CPU时间片。它并不会直接提升线程的优先级而是让当前线程主动放弃执行权从而让其他线程有机会运行 五线程安全问题 1同步代码块 //代码见 上面 --接 三1 synchronized (TicketThread.class) 总结一 ----认识同步监视器锁子 ----- synchronized(同步监视器){ }
必须是引用数据类型不能是基本数据类型也可以创建一个专门的同步监视器没有任何业务含义 一般使用共享资源做同步监视器即可 在同步代码块中不能改变同步监视器对象的引用 尽量不要String和包装类Integer做同步监视器 建议使用final修饰同步监视器 总结二 ----同步代码块的执行过程
第一个线程来到同步代码块发现同步监视器open状态需要close,然后执行其中的代码。第一个线程执行过程中发生了线程切换阻塞 就绪第一个线程失去了cpu但是没有开锁open。第二个线程获取了cpu来到了同步代码块发现同步监视器close状态无法执行其中的代码第二个线程也进入阻塞状态。第一个线程再次获取CPU,接着执行后续的代码同步代码块执行完毕释放锁open。第二个线程也再次获取cpu来到了同步代码块发现同步监视器open状态拿到锁并且上锁由阻塞状态进入就绪状态再进入运行状态重复第一个线程的处理过程加锁。强调同步代码块中能发生CPU的切换吗能 但是后续的被执行的线程也无法执行同步代码块因为锁仍旧close 。 总结三
多个代码块使用了同一个同步监视器锁锁住一个代码块的同时也锁住所有使用该锁的所有代码块其他线程无法访问其中的任何一个代码块 多个代码块使用了同一个同步监视器锁锁住一个代码块的同时也锁住所有使用该锁的所有代码块 但是没有锁住使用其他同步监视器的代码块其他线程有机会访问其他同步监视器的代码块 2同步方法 //代码见 上面 --接 三2 public synchronized void buyTicket(){ } 总结一
多线程在争抢资源就要实现线程的同步就要进行加锁并且这个锁必须是共享的必须是唯一的。咱们的锁一般都是引用数据类型的。目的解决了线程安全问题。 总结二 --- 关于同步方法 不要将run()定义为同步方法非静态同步方法的同步监视器是this静态同步方法的同步监视器是 类名.class 字节码信息对象同步代码块的效率要高于同步方法 ------------ 原因同步方法是将线程挡在了方法的外部而同步代码块锁将线程挡在了代码块的外部但是却是方法的内部同步方法的锁是this一旦锁住一个方法就锁住了所有的同步方法同步代码块只是锁住使用该同步监视器的代码块而没有锁住使用其他监视器的代码块 3Lock锁 //代码见 上面 --接 三3 Lock locknew ReentrantLock(); //多态 接口实现类 可以使用不同的实现类。。。。。。。。lock.lock();//打开锁。。。。。。。lock.unlock();//关闭锁---即使有异常这个锁也可以得到释放 Lock和synchronized的区别
Lock是显式锁手动开启和关闭锁别忘记关闭锁synchronized是隐式锁Lock只有代码块锁synchronized有代码块锁和方法锁.使用Lock锁JVM将花费较少的时间来调度线程性能更好。并且具有更好的扩展性提供更多的子类 优先使用顺序 Lock----同步代码块已经进入了方法体分配了相应资源----同步方法在方法体之外
