上海网站建设报价方案,嘉兴网站定制公司,杨陵区住房和城乡建设局网站,房产cms多线程入门
一、线程和进程 进程 进程#xff1a;是指一个内存中运行的应用程序#xff0c;每个进程都有一个独立的内存空间和系统资源#xff0c;一个应用程序可以同时运行多个进程#xff1b;进程也是程序的一次执行过程#xff0c;是系统运行程序的基本单位#xff1…多线程入门
一、线程和进程 进程 进程是指一个内存中运行的应用程序每个进程都有一个独立的内存空间和系统资源一个应用程序可以同时运行多个进程进程也是程序的一次执行过程是系统运行程序的基本单位系统运行一个程序即是一个进程从创建、运行到消亡的过程。进程是系统进行资源分配和调度的独立单位。 单cpu同一时间点只能执行一件事情CPU高效的切换让我们觉得是同时进行的 我们在同一个进程内可以执行多个任务每个任务就可以看成一个线程 进程就是正在运行的程序 进程是系统进行资源分配和调度的独立单位每一个进程都有它自己的内存空间和系统资源。 案例 百度云盘一个应用程序进程 下载功能可以同时下载多个文件 线程 线程线程是进程中的一个执行单元负责当前进程中程序的执行一个进程中至少有一个线程。一个进程中是可以有多个线程的这个应用程序也可以称之为多线程程序。 简而言之一个程序运行后至少有一个进程一个进程中可以包含多个线程 在同一个进程内可以执行多个任务而这个每个任务就是看成线程 **线程**是程序执行的单元,执行路径是程序使用cpu最基本单位。 cpu 只有一个, 每次只能执行一个线程 一个进程有多个线程 单线程 :如果程序只有只有一条执行路径 多线程:如果程序有多条执行路径
二、并行与并发
并发逻辑上同时发生指再某一个时间内同时运行的程序并行物理上同时发生指在某一个时间点同时运行的程序 三、多线程的意义嘛
多线程存在的意义:不是提高程序的执行速率,其实是为了提高程序的使用率。 程序的执行其实都是在抢cpu的资源cpu的执行权。 多个线程抢夺到cpu执行权的概率更大 线程抢夺执行权具有随机性
四、java程序的运行原理
由java命令启动jvm,启动jvm相当于启动了一个进程
接着该进程创建主线程main去调用main方法
jvm虚拟机的启动是单线程的还是多线程的多线程
原因是垃圾回收线程也要启动不然很容易就内存溢出
五、Thread的基本使用
1、创建线程的步骤
自定义一个类MyThread 继承Thread类重写run方法创建一个MyThread对象MyThread对象.start()
注 run 与 start 的区别
直接调用run方法还是在main线程中执行start() 方法, jvm会创建一个新线程然后jvm会自动运行新线程的run方法
2、创建多个线程的方法
注new 多个MyThread对象即可。不是要理解成调用多次start了
MyThread myThread new MyThread(张三); //这就是一个线程
MyThread myThread2 new MyThread(李四);
myThread.start();
myThread2.start();3、获得线程的名字 String getName() 返回该线程的名称。 可以在Thread的子类中直接使用 Thread.currentThread() : 得到当前线程对象
System.out.println(Thread.currentThread().getName());4、多线程独立栈空间 5、多线程的打印具有随机性 6、线程的调度
**分时调度**所有线程轮流使用CPU 的使用权平均分配每个线程占用 CPU 的时间。
**抢占式调度**优先让优先级高的线程使用 CPU如果线程的优先级相同那么会随机选择一个(线程随机性)
Java使用的是抢占式调度。
7、设置线程的优先级
抢占式调度详解大部分操作系统都支持多进程并发运行现在的操作系统几乎都支持同时运行多个程序。比如现在我 们上课一边使用idea编辑器一边使用录屏软件同时还开着画图板dos窗口等软件。此时这些程序是 在同时运行”感觉这些软件好像在同一时刻运行着“。 实际上CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言某个时刻只能执行一个线程而 CPU的在多个线程间切换速度相对我们的感觉要快看上去就是 在同一时刻运行。 其实多线程程序并不能提高程序的运行速度但能够提高程序运行效率让CPU的使用率更高。 线程优化级高并不能让线程先执行。它还是随机的只是概率高点
六、多线程好处: 充分利用CPU的资源多进程 多线程为当前程序抢占CPU使用权 简化编程模型 带来良好的用户体验 多个线程之间互不干扰
七、线程的控制
1、Thread类API
属性
NORM_PRIORITY : 值为 5
MAX_PRIORITY : 值为 10
MIN_PRIORITY : 值为 1构造方法 Thread():分配一个新的 Thread对象。。 Thread(String name):分配一个指定名字的新的线程对象。 Thread(Runnable target):分配一个带有指定目标新的线程对象。 Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
常用方法:
String getName():获取当前线程名称。static Thread currentThread():返回对当前正在执行的线程对象的引用。void setName(String name):将此线程的名称更改为等于参数 name 。void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。void run():此线程要执行的任务在此处定义代码。static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停暂时停止执行。int getPriority() :返回此线程的优先级。void setPriority(int newPriority) :更改此线程的优先级。void join() :等待这个线程死亡。static void yield():对调度程序的一个暗示即当前线程愿意让出当前使用的处理器。void interrupt():中断这个线程。boolean isAlive():测试这个线程是否活着。Thread.State getState():返回此线程的状态。
2、线程的休眠
public void run() {// 放让线程执行代码块for(int i0;i10;i){try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(getName()我是最棒的:i);}
}3、线程的加入
void join() :等待这个线程死亡。
MyThread myThread new MyThread(张三); //这就是一个线程
MyThread myThread2 new MyThread(李四);
myThread.start();
try {myThread.join();
} catch (InterruptedException e) {throw new RuntimeException(e);
}
myThread2.start();4、线程的礼让
static void yield():对调度程序的一个暗示即当前线程愿意让出当前使用的处理器。
public void run() {
// 放让线程执行代码块
for(int i0;i10;i){
Thread.yield(); //让出cpu 使用权
System.out.println(getName()我是最棒的:i);
}
}5、线程的中断
public final void stop (): 让线程停止过时了,但是还可以使用。**public void interrupt ( )**∶中断线程。把线程的状态终止并抛出一个InterruptedException.
6、线程的守护
public final void setDaemon(boolean on)
将此线程标记为daemon线程或用户线程。当运行的唯一线程都是守护进程线程时Java虚拟机将退出。
线程启动前必须调用此方法。
MyThread myThread new MyThread(张三); //这就是一个线程
MyThread myThread2 new MyThread(李四);
myThread.setDaemon(true);
myThread2.setDaemon(true);
myThread.start();
myThread2.start();
//myThread.interrupt();for(int i0;i10;i){System.out.println(Thread.currentThread().getName()我是最棒的:i);
}八、Runnable创建多线程
runable方式创建线程
创建一个Runable接口的实现类MyRunable重写run方法创建实现类MyRunable对象, myrunable创建Thread类的对象,把 myrunable对象作为构造参数传过去
九、创建多线程方式总结
实现多线程方式两种
方法1Thread类
自定义一个MyThread类继承Thread类在MyThread类中重写run方法创建MyThread类的对象启动线程对象。start()方法
方法2Runable 接口
定义一个Runable接口的实现类MyRunable类在MyRunable类中重写run方法创建MyRunable类的对象myRunable创建Thread类的对象且将myRunable对象作构造方法的参数传递启动线程 . start方法
问题为什么有了方法1还需要方法2
为了避免 java 中由于单继承带来的局限性runable接口实现的线程适合多个相同的代码去处理同一个资源的情况把线程的同程序的代码数据进行有效分享资源共享体现了面向对象思想
线程安全问题
案例卖票
出现同票原因
// 分析同票的原因
// 线程抢夺cpu 执行权时执行的代码具有原子性
// 原子性是指最基本的代码最小的语句出现负票的原因
如何解决
什么情况会出现线程安全问题
是否多线程环境是否有共享资源是否有多条语句操作共享资源
同步锁
同步代码块
锁对象任意对象
语法
synchronized (obj){//操作共享数据的代码}同步方法
同步方法的锁对象是this
public synchronized void sellTicket(){if(ticket0){ // c1 c2 c3 ticket 1try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName()第ticket张票);ticket--;// 0}
}同步静态方法
同步方法的锁对象是当前类的字节码对象反射会学习
public synchronized static void sellTicket(){if(ticket0){ // c1 c2 c3 ticket 1try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName()第ticket张票);ticket--;// 0}
}Lock锁
public void run() {while (true){lock.lock(); //上锁if(ticket0){try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName()第ticket张票);ticket--;// 0}lock.unlock(); //释放锁}}synchronized与lock的区别
synchronizedjvm级别的锁jvm自动上锁和解锁lock锁java代码的锁需要手动的加锁和释放锁
死锁
多线程产生死锁的四个必要条件
互斥条件一个资源每次只能被一个进程使用。保持和请求条件一个进程因请求资源而阻塞时对已获得资源保持不妨。不可剥夺调用进程已获得资源在未使用完成前不能被剥夺。循环等待条件若干进程之间形成一种头尾相接的循环等待资源关系。
public class MyThread extends Thread{private boolean flag;public MyThread(Boolean flag){this.flag flag;}Overridepublic void run() {if(flag){synchronized (LockObject.objA) { //try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(我有锁A,需要锁B);synchronized (LockObject.objB) {System.out.println(Thread.currentThread().getName() 我有锁);}}}else{synchronized (LockObject.objB) { //try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(我有锁A,需要锁B);synchronized (LockObject.objA) {System.out.println(Thread.currentThread().getName() 我有锁);}}}}
}public class LockObject {public static Object objA new Object();public static Object objB new Object();
}public class Example02 {public static void main(String[] args) {MyThread thread new MyThread(true);MyThread thread2 new MyThread(false);thread.start();thread2.start();}
}十、线程的生命周期
线程的生命周期状态
新建创建一个线程对象就绪对象调用start()方法有执行资格但是没有抢到CPU资源运行抢到了CPU资源有执行权阻塞通过sleep()wait()等方法让线程中断运行没有了执行资格死亡线程执行完毕等待垃圾回收 十一、线程之间的通信
生产者
先查看是否有资源有就等待没有就生产生产后通知消费者来消费资源
消费者
先查看是否有资源有就消费资源没有就通知生产者生产资源并等待 public class BaoZi { // 公共资源包子类public String name;public boolean flagfalse; //是否有资源public BaoZi(){}public String getName() {return name;}public void setName(String name) {this.name name;}public BaoZi(String name){this.name name;}
}// 生产者包包子的
public class SetBaoZi extends Thread{ private BaoZi bz;private int x 0;public SetBaoZi(BaoZi bz){this.bz bz;}Overridepublic void run() {while (true){synchronized (bz){if (bz.flag){ // 有资源不需要包包子等待资源消耗完try{bz.wait();} catch (InterruptedException e){throw new RuntimeException(e);}}if (x%20){bz.name 小笼包;}else {bz.name 酱肉包;}bz.notify(); // 唤醒消费者线程bz.flag true;x;}}}
}// 消费者
public class GetBaoZi extends Thread{private BaoZi bz;public GetBaoZi(BaoZi bz) {this.bz bz;}Overridepublic void run() {while (true){synchronized (bz){if (!bz.flag){try {bz.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println(消费了包子bz.name);bz.flag false;bz.notify(); // 包子被消费唤醒生产者线程包包子}}}
}// 测试
public class Test {public static void main(String[] args) {BaoZi baoZi new BaoZi();SetBaoZi setBaoZi new SetBaoZi(baoZi);GetBaoZi getBaoZi new GetBaoZi(baoZi);setBaoZi.start();getBaoZi.start();}
}// 加锁解决了消费资源出错的问题
// 使用wait和notify解决了多次消费同一资源的问题
线程间通信的内存图
常见情况
新建 – 就绪 – 运行 – 死亡新建 – 就绪 – 运行 – 就绪 – 运行 – 死亡新建 – 就绪 – 运行 – 等待阻塞 – 同步阻塞 – 就绪 – 运行–死亡新建 – 就绪 – 运行 – 其它阻塞 – 就绪 – 运行–死亡新建 – 就绪 – 运行 – 同步阻塞 – 就绪 – 运行–死亡 十二、线程池
使用线程池的思想池化思想可以提高重用性和效率Executors。
class MyCallable implements Callable {Overridepublic Object call() throws Exception {System.out.println(我是callable方法);return null;}
}
public class Example01 {public static void main(String[] args) {ExecutorService service Executors.newFixedThreadPool(2);MyCallable myCallable1 new MyCallable();MyCallable myCallable2 new MyCallable();service.submit(myCallable1);service.submit(myCallable2);}
}
十二、线程池
使用线程池的思想池化思想可以提高重用性和效率Executors。
class MyCallable implements Callable {Overridepublic Object call() throws Exception {System.out.println(我是callable方法);return null;}
}
public class Example01 {public static void main(String[] args) {ExecutorService service Executors.newFixedThreadPool(2);MyCallable myCallable1 new MyCallable();MyCallable myCallable2 new MyCallable();service.submit(myCallable1);service.submit(myCallable2);}
}
