免费的企业网站建设,wordpress菜单联动,自己如何注册网站,雄安 网站建设1. 线程两个基本概念 并发#xff1a;即线程交替运行多个指令并行#xff1a;即多个线程同时运行指令 并发并行不矛盾#xff0c;两者可同时发生#xff0c;即多个线程交替运行指令 2. 多线程3种实现方式
2.1 直接创建线程对象 /*** 方式1#xff1a;* 1. 创建thread类的…1. 线程两个基本概念 并发即线程交替运行多个指令并行即多个线程同时运行指令 并发并行不矛盾两者可同时发生即多个线程交替运行指令 2. 多线程3种实现方式
2.1 直接创建线程对象 /*** 方式1* 1. 创建thread类的子类* 2. 将该子类实列化* 3. 实列化对象调用start方法即开启多线程* */myThread myThread1 new myThread();myThread1.setName(线程1);myThread1.start();myThread myThread2 new myThread();myThread2.setName(线程2);myThread2.start();public class myThread extends Thread{Overridepublic void run() {for (int i 0; i 20; i) {System.out.println(getName() 看看哪个线程在执行指令);}}
} 2.2 实现Runnable接口 //方法2/** 1. 定义类实现runnable接口* 2. 重写Runnable接口的run方法* 3. 创建自己类对象* 4. 创建线程将自己类这个指令添加到线程开启线程* *///因为没有继承thread类无法直接调用start方法此时该类对象充当要执行的指令再把该指令添加到线程中即可//可直接获取线程对象或者调用thread类里面获取线程对象的方法mythread mt1 new mythread();Thread t1 new Thread(mt1);Thread t2 new Thread(mt1);t1.setName(线程1);t2.setName(线程2);t1.start();t2.start();}public class mythread implements Runnable{Overridepublic void run() {for (int i 0; i 20; i) {System.out.println(Thread.currentThread().getName() 第二个方法哟);}}
}
2.3 利用Callable、Future接口
//方法3利用Callable、Future接口实现/** 1. 定义类实现Callable接口并重写该接口的call方法* 2. 创建自己类的对象即将要执行的指令对象* 3. 创建FutureTask对象即接收执行指令最终返回的结果* 4. 创建Thread对象将要执行的指令添加到线程对象中并开启线程* *///1. 定义类实现Callable接口并且重写call方法//2. 创建指令类对象mythread mythread new mythread();//3. 创建接收指令类返回结果的FutureTask对象此时里面参数代表接收该指令类对象返回的参数FutureTaskInteger integerFutureTask new FutureTaskInteger(mythread);//将指令添加到线程对象中Thread thread new Thread(integerFutureTask);thread.start();System.out.println(integerFutureTask.get());public class mythread implements CallableInteger {Overridepublic Integer call() throws Exception {int sum 0;for (int i 1; i 10; i) {sum i;}return sum;}
} 三者区别 第一种实现方式扩展性较差因为要有继承关系即已经继承了Thread类那么该类无法在继承别的类而方式2、3定义的类只是实现了接口还可以继承其他类扩展性较好第二种方式相对第三种语法较为简洁第三种可以获取指令最终的返回结果适用于需要返回结果的场景前两种方式无返回值无法获取指令的返回结果 3. 线程常用方法
3.1 线程优先级 优先级高的线程先执行的概率更高但不是绝对线程的执行时机都是随机事件概率问题Java中默认的线程默认优先级为5可以调用方法更改线程的优先级 3.2 守护线程 当未守护线程全都执行完毕守护线程也随之结束 3.3 礼让线程 礼让线程可让线程的执行尽可能的均匀 public class yieldThread implements Runnable{Overridepublic void run() {for (int i 0; i 10; i) {System.out.println(Thread.currentThread().getName() 礼让线程鸭);Thread.yield();}}
} 3.4 插入线程 Java虚拟机默认先执行完main线程在执行其他线程若要其他线程在main线程之前执行可调用插入线程方法 //插入线程/** 执行线程* 虚拟机默认先执行main线程当main线程执行完毕在执行其他线程若想其他线程在main线程之前执行得调用插入线程方法* *///创建要执行指令的对象joinThread jt new joinThread();//创建线程对象要执行的指令添加进线程Thread t new Thread(jt);//执行线程//插入线程t.start();t.join();for (int i 0; i 10; i) {System.out.println(main线程在执行哟);} 4. 线程生命周期 5. 解决多线程问题
5.1 同步代码块
用于解决线程安全问题需要用到synchronized关键字
public class windowThread implements Runnable {static int ticket 0;Overridepublic void run() {//定义个卖票指令实现多个窗口同时买票while (true) {//若要避免线程安全问题可用到synchronized关键字括号里面的对象充当门锁默认是打开的当有线程对象进去门锁关闭//如此时窗口1争夺到cpu的执行权那么就会进去到了sleep睡眠时此时没有资格争夺cpu执行权假设此时窗口2争夺到//但是因为窗口1已经进去门锁此时关闭而争夺执到执行权的窗口2也只能在门外等候等待窗口1出来才门才会开锁//此时的门锁可以避免多条线程同时执行下面的代码块从而引发同一张票被3个窗口同时卖出的线程安全问题/*** 锁细节* 所有线程对象用到的门锁必须是唯一的* 一般用类的字节码文件作为锁对象保证锁的唯一性* */synchronized (windowThread.class) {if (ticket 100) {try {//一旦线程运行到此处即休眠10毫秒无法争夺cpu执行权休眠过后继续执行后面代码//只有该线程执行完synchronized的代码锁才会打开Thread.sleep(10);ticket;System.out.println(Thread.currentThread().getName() 正在卖第 ticket 张票);} catch (InterruptedException e) {throw new RuntimeException(e);}} else {break;}}}}
} 5.2 同步方法
被synchronized关键字修饰的方法为同步方法该方法执行完才会开锁
public class myRunnable implements Runnable {int ticket 0;Overridepublic void run() {while (true) {//同步方法即将同步代码块抽取成方法即可//被synchronized即同步方法当一个方法的代码全部要被锁起来可以运用到该方式if (method()) break;}}private synchronized boolean method() {if (ticket 100) {try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket;System.out.println(Thread.currentThread().getName() 正在卖第 ticket 张票);} else {return true;}return false;}
}
6. 锁Lock
synchronized关键字修饰的代码块会自动进行开关锁而不用这个关键字也开业手动开关机解决线程问题
public class mtThread extends Thread {static int ticket 0;//创建锁对象因为此时定义的类继承Thread类即会有很多线程对象//而静态关键字修饰的锁对象不管该类实列化多少对象该锁都仅有一个//确保了每个实例化对象对应的锁的唯一性static Lock lock new ReentrantLock();Overridepublic void run() {while (true) {//手动关锁当线程对象进入后未开锁之前其他对象不能进入锁下面的代码块lock.lock();try {if (ticket 100) {break;} else {//线程对象执行到此处一样会进行休眠不参与争夺cpu//当其他线程对象争夺到cpu时会被关在锁外即无法执行此时的try、catch语句//只有当锁重新打开才能继续执行Thread.sleep(10);ticket;System.out.println(Thread.currentThread().getName() 正在售卖第 ticket 张票);}} catch (InterruptedException e) {throw new RuntimeException(e);} finally {//打开锁获得cpu运行权的对象开锁执行代码lock.unlock();}}}
} 7. 死锁 当两个锁嵌套使用时容易产生死锁问题当死锁发生程序将会卡死在锁的门外无法在运行下去故锁不能嵌套使用 8. 唤醒等待机制 唤醒等待机制可以使线程协调运行比如线程1运行一次线程2也运行一次 生产者和消费者实现唤醒等待机制
public class test {public static void main(String[] args) {//等待唤醒机制使得线程协调运行/** 三个对象* 1. 生产者* 2. 消费者* 3. 平台* */Consumer consumer new Consumer();Producer producer new Producer();consumer.setName(消费者);producer.setName(生产者);consumer.start();producer.start();}
}public class Desk {//三个属性作为协调的依据//判断当前桌子上是否有食物线程是否运行// 0:没有食物 1有食物static int foodFlag 0;//判断当前食物运行次数还剩多少线程运行次数static int count 10;//锁对象static Lock lock new ReentrantLock();
}public class Consumer extends Thread{/*** 1. 判断线程次数是否完成* 2. 判断桌子上是否有食物* 3. 有食物则吃掉次数减一* 4. 没有食物则等候并且唤醒生产者* */Overridepublic void run() {while (true) {synchronized (Desk.lock) {//判断线程次数if (Desk.count 0) {break;}//判断是否有食物if (Desk.foodFlag 1) {//有则直接吃掉并且次数减一System.out.println(this.getName() 正在吃掉第 Desk.count 份食物);//吃掉之后则生产者继续生产即唤醒另一线程Desk.lock.notify();Desk.foodFlag 0;Desk.count--;} else {try {//让该线程和锁进行绑定Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}}}}
}public class Producer extends Thread{/*** 1. 判断线程次数是否运行完成* 2. 判断桌面上是否有食物该线程是否运行* 3. 有则等候线程等候并唤醒等候线程* 4. 没有则做食物线程运行* */Overridepublic void run() {while (true) {synchronized (Desk.lock) {//判断线程次数是否运行完成if (Desk.count 0) {break;}if (Desk.foodFlag 1) {//有则等候并唤醒该锁对象的等候线程try {//让该线程和锁进行帮Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}} else {//没有则做食物System.out.println(this.getName() 正在制作第 Desk.count 份食物);//制作之后则消费者消费即唤醒另一线程Desk.lock.notify();Desk.foodFlag 1;}}}}
}
阻塞队列实现唤醒等待机制
用到Java提供的队列类BlockingQueue此时的队列充当平台线程之间数据交换协调的平台要保证线程在同一队列之间协调运行
public class test {public static void main(String[] args) {//阻塞队列实现唤醒等待机制/*** 生产者* 消费者* 队列生产者和消费者必须在同一队列进行生产消费* *///创建队列对象ArrayBlockingQueueString queue new ArrayBlockingQueueString(3);//创建两条线程Consumer c new Consumer(queue);Producer p new Producer(queue);p.start();c.start();}
}public class Producer extends Thread{ArrayBlockingQueueString queue;//要保证在同一队列进行生产消费可在构造方法中传递队列对象public Producer(ArrayBlockingQueueString queue) {this.queue queue;}//重写线程运行方法Overridepublic void run() {while (true) {try {//该队列的方法中已经写好开关锁不需要我们自己写锁queue.put(好吃的鸭);System.out.println(做了好吃的鸭);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}public class Consumer extends Thread{ArrayBlockingQueueString queue;//获取队列对象要保证同一队列可在构造方法中传递队列对象public Consumer(ArrayBlockingQueueString queue) {this.queue queue;}//重写Run方法Overridepublic void run() {while (true) {try {//该队列已经写好开关锁不需要我们手动写若在写锁就造成嵌套锁容易形成死锁问题String food queue.take();System.out.println(food);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}9. 线程池 没有线程池存放线程时我们创建的线程当运行完毕会自动销毁而线程池可以存储线程提高资源复用率 线程池原理 创建线程池时里面是空的没有任何线程当有任务添加进线程池时先创建线程运行任务当任务运行完毕线程并不会销毁而是保留在池子中若在有新任务添加而原先创建的线程并没有运行任务则会直接复用线程并不会立刻创建新线程·当线程池的线程数量达到线程池规定数量上限就不会在创建新线程而未运行到的任务只能排队等待 获取线程池对象的方式 用工具类 Executors直接创建 未完待续......
