新乡网站开发的公司电话,南宁网站定制开发,电脑云主机,云南微网站开发进程#xff1a;计算机执行的任务 线程#xff1a;执行任务中的小任务 多线程 计算机再执行过程中#xff0c;再同一时间只能让cpu的一个核执行一个进程。进程有多个线程构成#xff0c;再同一时刻Cpu只能处理一个线程。 引入多线程 当线程被cpu执行时cpu开始工作#xff…进程计算机执行的任务 线程执行任务中的小任务 多线程 计算机再执行过程中再同一时间只能让cpu的一个核执行一个进程。进程有多个线程构成再同一时刻Cpu只能处理一个线程。 引入多线程 当线程被cpu执行时cpu开始工作线程需要和软硬件进行交互这个时候cpu就是处于空闲状态 引用多线程可以提高cpu的使用效率 创建多线程的方式-----(Thead) 1.继承Thread类重写run方法(线程代码逻辑所在的地方调用start方法开启线程. 有一个不好的地方就是java是单继承所以我们继承了Thread后就不能继承其他类 所以我们通常采用第二种方法 实现接口 public class ThreadDemo {public static void main(String[] args) {//线程执行---执行线程逻辑所在的类Demo dnew Demo();//标记线程可以被cpu执行d.start();for(int i0;i10;i){System.out.println(main:i);}}}
//线程任务的执行的代码逻辑
class Demo extends Thread{//重写方法----实现线程的代码逻辑Overridepublic void run() {for(int i0;i10;i){System.out.println(ii);}}
} 2.实现Runnable接口重写run方法(线程代码逻辑),通过Runnable接口的实现类对象构建Thread类对象调用start方法开启线程 public class ThreadDemo2 {public static void main(String[] args) {//通过Runnable实现类对象构建Thread类对象Thread tnew Thread(new TDemo() );//开启线程t.start();for(int i0;i10;i){System.out.println(main:i);}}}
//线程代码逻辑所在类实现Runnable接口
class TDemo implements Runnable{//重写方法 --线程代码逻辑Overridepublic void run() {for(int i0;i10;i){System.out.println(ii);}}
} 3.实现Callable接口重写call方法现阶段了解就好) import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;public class ThreadDemo3 {
public static void main(String[] args) throws InterruptedException, ExecutionException {//创建线程类对象DTDemo1 dtnew DTDemo1();//获取执行服务器,ExecutorService eExecutors.newCachedThreadPool();//把你想要操作的东西放到执行服务器上FutureInteger f e.submit(dt);System.out.println(f.get());
}
}
//Integer 重写方法返回值类型
class DTDemo1 implements CallableInteger{//重写方法----线程代码逻辑所在的地方Overridepublic Integer call() throws Exception {// TODO Auto-generated method stubreturn 20;}} 因为底层多线程之间存在抢占问题抢占发生再代码的每一步导致了数据安全问题 为了排除我们多线程的抢占问题我们采用加锁的策略有两种 1.同步代码块锁同步方法锁 同步代码块锁--synchtonized锁对象{} ----锁对象指的是 可以被线程共享--方法区里的内容可以被所有线程共享对多少个线程对象进行加锁这些对象都是同步的 同步方法锁--在方法上加上synchronized,如果这个方法是静态方法锁对象就是类名.class,如果这个方法是非静态方法锁对象就是this构造器和属性上不能夹synchronized 同步:多个线程每次只能执行一个一个一个 异步多个线程每次可以执行多个(抢占) 同步一定是安全的 安全的不一定是同步 不安全一定是异步 异步不一定不安全 从微观上同步一定是安全的异步一定是不安全的 public class SellTicketDemo {public static void main(String[] args) {//创建票类对象Ticket tnew Ticket();//设置票数t.setCount(100);//四个售票员Seller s1new Seller(t);Seller s2new Seller(t);Seller s3new Seller(t);Seller s4new Seller(t);//开启线程 并给每个线程new Thread(s1,A).start();new Thread(s2,B).start();new Thread(s3,C).start();new Thread(s4,D).start();}
}
//模拟卖票的过程---线程的代码逻辑
class Seller implements Runnable{//引入票类Ticket t;//有参构造public Seller(Ticket t) {this.tt;}//线程的代码逻辑---买票的过程//同步方法锁是直接加在方法上 同步方法锁如果是非静态方法那么他的锁对象是this//如果是静态方法的话那么锁对象就是类名.classOverridepublic synchronized void run() {while(true){ //同步代码块锁---()中的是锁对象 ----被线程共享,只要是能被所有对象共享的就可以锁对象必须被所有被执行的线程共享 方法区中的就可以因为方法区是被所有的线程共享的但是范围太大了能小的锁就小得锁synchronized (Seller.class) {if(t.getCount()0) //票买完的时候就是票数为0{break;}//设置新的票数t.setCount(t.getCount()-1);//打印出具体是那个售票员卖的----具体是那个线程执行的//Thread.currentThread()当前正在执行的线程System.out.println(Thread.currentThread().getName()买了一张票还剩t.getCount()票);}}}}//表示票类
class Ticket{//属性//票数private int count;public int getCount() {return count;}public void setCount(int count) {this.count count;}} 锁之间的相互嵌套----死锁 public class DeadLoackDemo {//static Print pnew Print();static Scan snew Scan();public static void main(String[] args) {//开启线程new Thread(new Runnable() {Overridepublic void run() {// TODO Auto-generated method stub//打印信息synchronized (p) {p.print();//让线程进行休眠---线程释放执行权try { Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//扫描synchronized (s) {s.sacnn();}}}}).start();new Thread(new Runnable() {Overridepublic void run() {// TODO Auto-generated method stub//先扫描synchronized (s) {s.sacnn();synchronized (p) {p.print();}}}}).start();}
}//打印机
class Print{public void print(){System.out.println(在打印东西...);}
}//扫描仪
class Scan{public void sacnn(){System.out.println(在扫描信息...);}
} 如果破解死锁上面的死锁出现的问题是两个线程需要同一个锁如果一个走一个等待那么就不会产生死锁现象所以我们需要控制锁一个锁走完再让另一个线程获取这个锁 package cn.tedu.thread;public class WaitNotifyDemo {public static void main(String[] args) {//创建学生类对象Student snew Student();s.setName(lili);s.setGender(女);//开启线程new Thread(new Ask(s)).start();new Thread(new Change(s)).start();}
}//线程所在的类---问问题
class Ask implements Runnable{// 引入学生类对象private Student s;public Ask(Student s){this.ss;}Overridepublic void run() {// TODO Auto-generated method stub//表示问问题的结果while(true){synchronized (s) { //防止多线程抢占保证性别//释放线程执行权---等待if(s.flagfalse)try {//让线程等待----相当于堵塞主要是为了挨个回答问题s.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//输出System.out.println(老师你好我是s.getName()是一个s.getGender()生想问问题...);//唤醒线程s.notify();//改变布尔值s.flagfalse;}}}}//线程所在的类---换学生
class Change implements Runnable{//引入学生类对象private Student s;public Change(Student s){this.ss;}Overridepublic void run() {// TODO Auto-generated method stubwhile(true){synchronized (s) { //防止多线程的抢占---保证性别//线程等待if(s.flagtrue)try {s.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//if (s.getName().equals(tom)) {s.setName(lili);s.setGender(女);} else {s.setName(tom);s.setGender(男);}//线程唤醒s.notify(); //唤醒阻塞的线程CPU可以将阻塞的线程抢执行权了。//改变布尔值s.flagtrue;}}}}//学生类
class Student{//属性private String name;private char gender;//boolean flagtrue;public char getGender() {return gender;}public void setGender(char gender) {this.gender gender;}public String getName() {return name;}public void setName(String name) {this.name name;}} wait、notify、notifyAll是线程中通信可以使用的方法。线程中调用了wait方法则进入阻塞状态只有等另一个线程调用与wait同一个对象的notify方法。这里有个特殊的地方调用wait或者notify前提是需要获取锁也就是说需要在同步块中做以上操作。 等待唤醒的前提唤醒一个 是得有锁 notify()随机唤醒 肯定给你唤醒一个 作用 唤醒阻塞的线程CPU可以将阻塞的线程抢执行权了。两个对象的话就是一个线程执行一次因为只有一种情况一个线程再执行另一个再阻塞 wait和sleep的区别 sleep--用于是线程进入休眠状态需要制定休眠的时间到了这个时间才会唤醒,在其s0leep时间段内该线程不会获得执行的机会即使系统种没有其他可以运行的线程如果线程没有加锁就会释放线程的执行权如果加锁就不会释放执行权但是会有CPU的切换 可以指定休眠时间 这是Thread的静态方法 wait---如果指定等待时间就必须等到时间结束才能唤醒如果不指定时间就只能手动唤醒如果线程加锁就会释放锁也能释放执行权如果没有加锁就释放执行权是Object里的普通方法 线程状态 当线程被创建并启动以后它既不是以启动就进入了执行状态也不是一致处于执行状态在线程的生命周期中他要径路新建就绪运行阻塞和死亡5种状态。 尤其是线程启动以后它不能一直“霸占” 着CPU独自运行所以CPU需要在多条线程之间切换于是线程状态也会多次在运行、阻塞之间切换 1.新建当程序使用new关键字创建了一个线程之后该线程就处于新建状态此时它和其他java对象一样仅仅有java虚拟机为其分配了内存并初始化了其成员变量的值。此时的线程对象没有表现出任何线程的动态特征程序也不会执行线程的线程执行体。 2.就绪状态当线程对象调用了start方法之后该线程处于就绪状态java虚拟机会为其创建方法调用栈和程序计数器处于这个状态下的线程并没有开始运行它只是表示该线程可以运行了至于该线程何时开始运行取决于jvm里线程调度器的调度 不要对已经处于启动状态的线程再次调用start方法否则将引发IllegalThreadStateException异常 如果程序希望调用子线程的start()方法后子线程立即开始执行程序可以使用Thread.sleep(1)来让当前运行的线程(主线程)睡眠一毫秒---1毫秒就够了因为在这1毫秒内CPU不会空闲它就会去执行另一条就绪状态的线程这样就可以让我们的子线程立即获得执行 守护线程 需要手动开启如果被守护线程执行结束守护线程也随着结束反之不是 如果有多个线程除了守护 线程其他的都是被守护线程 java中最大的守护线程是GC package cn.tedu.thread;public class DemonDemo {public static void main(String[] args) {//创建出小兵对象Thread t1new Thread(new Soilder(),小兵1);Thread t2new Thread(new Soilder(),小兵2);Thread t3new Thread(new Soilder(),小兵3);Thread t4new Thread(new Soilder(),小兵4);//设置守护线程t1.setDaemon(true); //true代表手动开启守护线程t2.setDaemon(true);t3.setDaemon(true);t4.setDaemon(true);//开启线程t1.start();t2.start();t3.start();t4.start();//被守护线程for(int i10;i0;i--){System.out.println(boss剩余i);}}}//线程类---小兵
class Soilder implements Runnable{Overridepublic void run() {// TODO Auto-generated method stub//输出每个小兵的剩余血量for(int i10;i0;i--){System.out.println(Thread.currentThread().getName()还剩i滴血...);}//线程走的太快就让慢点方便自己查看结果try {Thread.sleep(10);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} 前台线程死亡后jvm会通知后台线程死亡但从它接受命令到它做出响应需要一定时间而且要将某个线程设置为后台线程必须在该线程启动之前设置也就是说setDaemon(true)必须在start()方法调用之前否则会引发IllegalThreadStateException 线程优先级 优先级(1-10)理论上优先级越大越有机会抢到执行权理论上如果线程1与线程2之间的优先级之差大于5那么线程1强到执行权的机会比线程2大一点。就算你设置成10和1差距也不大功能比较鸡肋 package cn.tedu.thread;public class PririotyDemo {public static void main(String[] args) {Thread t1new Thread(new PDemo(),A);Thread t2new Thread(new PDemo(),B);//设置优先级t1.setPriority(1);t2.setPriority(9);//开启线程t1.start();t2.start();}}class PDemo implements Runnable{Overridepublic void run() {// TODO Auto-generated method stubfor(int i0;i10;i){System.out.println(Thread.currentThread().getName());}}//
} 生产者和消费者问题 //生产消费模型
public class WaitNotifyText {public static void main(String[] args) {//商品对象Product pnew Product();//开启线程new Thread(new Productor(p)).start();new Thread(new Productor(p)).start();new Thread(new Consumer(p)).start();new Thread(new Consumer(p)).start();}
}//模拟生产过程---线程逻辑代码
class Productor implements Runnable{//引入商品类Product p;public Productor(Product p){this.pp;}//重写Overridepublic void run() {while (true) {synchronized (p) {while(p.flagtrue)//加上while保证线程一定会进行判断try {p.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}// TODO Auto-generated method stub// 此时生产的最大值int max 1000 - p.getNum();// 减去上次剩余// 随机生产的商品数量int count (int) (Math.random() * (max 1));// 设置新的商品数量p.setNum(p.getNum() count);// 输出System.out.println(此次生产了 count 个商品,还剩余 p.getNum() 个商品...);//唤醒//p.notify();//随机唤醒一个p.notifyAll();p.flagtrue;}}}}//模拟消费过程
class Consumer implements Runnable{// 引入商品类Product p;public Consumer(Product p){this.pp;}Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {synchronized (p) {while(p.flagfalse)try {p.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}// 此次消费最大值int max p.getNum();// 此次消费的随机商品数量int count (int) (Math.random() * (max 1));// 设置新的商品数量p.setNum(p.getNum() - count);// 输出System.out.println(此次消费了 count 个商品,还剩余 p.getNum() 个商品...);//唤醒//p.notify();p.notifyAll();p.flagfalse;}}}}//商品类
class Product{//商品数量private int num;//boolean flagtrue;public int getNum() {return num;}public void setNum(int num) {this.num num;}} 转载于:https://www.cnblogs.com/xuwangqi/p/11249416.html
