多线程
并发执行的技术
并发和并行
并发:同一时间 有多个指令 在单个CPU上 交替执行
并行:同一时间 有多个指令 在多个CPU上 执行
进程和线程
进程:独立运行 任何进程 都可以同其他进程一起 并发执行
线程:是进程中的单个顺序控制流 是一条执行路径 线程又分为单线程和多线程
单线程:
多线程:JVM是多线程 其实就是JVM的主线程和垃圾回收线程在工作 结果在切换着运行
多线程的运行方式:他们拥有相等的运行权限 但运行过程是谁先抢到CPU的运行权限那么谁就先运行
线程的五种状态:新建,就绪,运行,堵塞,死亡
线程的实现:
方式一:继承Thread类
建立一个类继承Thread类 那么这类创建的对象可以并发的作为独立线程运行
继承的好处是可以使用父类中的方法 比较简单
继承的弊端是如果已经有父类了 就不可以再继承了 一个子类只能继承一个父类
public class Demo02 {public static void main(String[] args) {MyThread1 m1=new MyThread1();MyThread2 m2=new MyThread2();MyThread3 m3=new MyThread3();//普通方法/* m1.run();m2.run();m3.run();*///start开启新线程 内部会根据cpu的分配自动执行runm1.start();m2.start();m3.start();//相当于跑步比赛的发令枪 启动后主线程与其他线程都会等待抢到cpu的执行权//谁先抢到谁运行}
}
//建立一个类继承Thread类 那么这类创建的对象可以并发的作为独立线程运行
class MyThread1 extends Thread{public void run(){for (int i = 0; i <10000000 ; i++) {System.out.println("1号线程");}}
}
class MyThread2 extends Thread{public void run(){for (int i = 0; i <10000000 ; i++) {System.out.println("2号线程");}}
}
class MyThread3 extends Thread{public void run(){for (int i = 0; i <10000000 ; i++) {System.out.println("3号线程");}}
}
方式二:实现Runnable接口
建立一个类实现Runnable接口
接口的好处是就算实现了其他接口 也可以使用
接口的弊端 操作不便利 需要先获取Thread线程对象
public class Demo03 {public static void main(String[] args) {My1 my1=new My1();Thread t1=new Thread(my1);My2 my2=new My2();Thread t2=new Thread(my2);t1.start();t2.start();}
}
//定义一个类 实现Runnable接口 重新run方法class My1 implements Runnable{@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("1号线程");}}
}class My2 implements Runnable{@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("2号线程");}}
}
start()方法把当前线程交给了底层的 ThreadGroup group[]数组管理
Jvm根据随机分配的cpu执行权调用run() 随机分配的cpu执行权是相等概率的
匿名内部类实现线程
方式一:继承Thread类
public static void main(String[] args) {new Thread(){public void run(){for(int i=0;i<10000000;i++){new Student();System.out.println("线程1");}}}.start();new Thread(){public void run(){for(int i=0;i<10000000;i++){new Student();System.out.println("线程2");}}}.start();}
方式二:实现Runnable接口
public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("1号线程");}}}).start();new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("2号线程");}}}).start();}
有名内部类实现线程
public static void main(String[] args) {Thread t1=new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("1号线程");}}});Thread t2=new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println("2号线程");}}});t1.start();t2.start();}
设置名字和获取名字(getName() setName())
可以在运行中获取当前线程的对象Thread.currentThread()
public class Demo06 {public static void main(String[] args) {Thread t1=new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {//Thread.currentThread()获取当前运行的线程对象//获取名字getName()System.out.println(Thread.currentThread().getName());}}});Thread t2=new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i <10000000 ; i++) {System.out.println(Thread.currentThread().getName());}}});//设置名字t1.setName("线程1");t1.start();t2.setName("线程2");t2.start();}
}
通过构造方法给线程取名
public class Demo06 {public static void main(String[] args){//通过构造方法给线程取名Thread t1=new Thread(new M1(),"my1");Thread t2=new Thread(new M2(),"my2");t1.start();t2.start();}
}
class M1 implements Runnable{@Overridepublic void run() {for (int i = 0; i <100000 ; i++) {System.out.println(Thread.currentThread().getName());}}
}
class M2 implements Runnable{@Overridepublic void run() {for (int i = 0; i <100000 ; i++) {System.out.println(Thread.currentThread().getName());}}
}
休眠
Thread.sleep(100);让当前线程休眠100毫秒
class MM1 implements Runnable{@Overridepublic void run() {for (int i = 0; i <100000 ; i++) {System.out.println(Thread.currentThread().getName());try {//让当前线程休眠100毫秒Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
守护线程
线程.setDaemon(true);
设置一个线程为守护线程 该线程不会单独执行 当其他非守护线程都执行结束后 再自动退出
public class Demo08 {public static void main(String[] args) {M2Thread m2=new M2Thread();m2.setName("线程2");m2.start();M1Thread m1=new M1Thread();m1.setName("线程1");m1.start();//守护线程不会单独执行Thread1 t=new Thread1();t.setName("守护线程");t.setDaemon(true);//设置true为守护线程 主线程结束 守护线程也结束t.start();}
}
class M1Thread extends Thread{public void run(){for (int i = 0; i <100 ; i++) {System.out.println(Thread.currentThread().getName());}}
}
class M2Thread extends Thread{public void run(){for (int i = 0; i <100 ; i++) {System.out.println(Thread.currentThread().getName());}}
}
class Thread1 extends Thread{public void run(){for (int i = 0; i <10000 ; i++) {System.out.println(Thread.currentThread().getName()+i);}}
}
加入线程
线程.join(可以限定时间 也可以不限定);
public static void main(String[] args) {Thread t1=new Thread("女朋友的电话"){public void run(){for (int i = 0; i <100 ; i++) {System.out.println(Thread.currentThread().getName()+i);}}};Thread t2=new Thread("老板的电话"){public void run(){for (int i = 0; i <100 ; i++) {System.out.println(Thread.currentThread().getName()+i);if(i==50){try {//加入女朋友的线程 基本全面占有cpu执行权// t2线程要等待t1线程执行完毕后才可以继续执行t1.join();//可以限定时间} catch (InterruptedException e) {throw new RuntimeException(e);}}}}};t1.start();t2.start();}
礼让(了解)
Thread.yield();//让出cpu的执行权给别的线程
设置优先级:(优先级1-10 默认为5)
线程.setPriority(10);
同步(同步锁,同步代码块)
注意:开发中尽量不要嵌套同步代码块 可能会死锁
关键字:synchronized(同步锁使用的多)
public class Test {String s="123";//同步锁 在方法中加synchronized关键字//public synchronized void show1(){} public synchronized void show1(){System.out.print("我");System.out.print("爱");System.out.print("学");System.out.print("习");System.out.println("-----------");}public void show2(){//同步代码块synchronized(s锁对象){}//多个同步代码块如果使用相同的锁对象 那么他们就是同步的synchronized(s){ System.out.print("想");System.out.print("睡");System.out.print("觉");System.out.println("===========");}}
}
线程安全
synchronized线程安全 没有synchronized线程不安全
Vector线程安全 ArrayList线程不安全
Stringbuffer安全 stringBuilder不安全
HashTable安全 HashMap不安全
设计模式
单例设计模式
public class Single {private Single(){//私有构造方法 不让其他类new对象}static Single s=new Single();
}
public static void main(String[] args) {Single s1=Single.s;Single s2=Single.s;System.out.println(s1==s2);//trueSingle s3=null;//对象可以被修改Single s4=Single.s;System.out.println(s3==s4);//false}
饿汉式(直接加载)
节约时间 浪费空间(例如:安卓手机应用可以在后台运行)
一旦被加载进来 就创建好了对象 不管是否使用 都在内存中
public class Single1 {private Single1(){//私有构造方法 不让其他类new对象}static Single1 s=new Single1();//饿汉式public static Single1 getInstance(){//一旦被加载进来 就创建好了对象 不管是否使用 都在内存中return s;}
}
public static void main(String[] args) {Single s1=Single.getInstance();Single s2=Single.getInstance();System.out.println(s1==s2);//true}
懒汉式(延迟加载)
节约空间 浪费时间(例如:苹果手机应用不挂后台)
什么时候用 什么时候才创建
public class Single2 {private Single2(){}public static Single2 s=null;//懒汉式public static Single2 Instance(){//需要的时候才创建对象if(s==null){s=new Single2();}return s;}
}
Runtime类单例(查API)
每个 Java 应用程序都有一个Runtime
类实例 使应用程序能够与其运行的环境相连接 可以通过 getRuntime
方法获取当前运行时。
应用程序不能创建自己的 Runtime
类实例
public static void main(String[] args) {Runtime r=Runtime.getRuntime();try {//r.exec("mspaint");//打开画图//r.exec("notepad");//打开记事本//r.exec("shutdown -s -t 6000");//6000秒后自动关机//r.exec("shurdown -a");//取消自动关机//r.exec("百度去");} catch (IOException e) {throw new RuntimeException(e);}}
Timer类(计时器)
用来定时执行程序的类
public class MyTask extends TimerTask {@Overridepublic void run() {System.out.println("起床了");}
}
public static void main(String[] args) {//用来定时执行程序的类Timer t=new Timer();//5秒后执行任务t.schedule(new MyTask(),new Date(System.currentTimeMillis()+5000));//5秒后执行任务 每隔1秒重复执行t.schedule(new MyTask(),new Date(System.currentTimeMillis()+5000),1000);}
线程通信(等待,唤醒)
必须在同步代码块中 使用同步锁对象调用(唤醒 等待 唤醒 等待)代码交替运行
并发执行时 默认情况下 cpu的执行权 是随机的 谁先抢到谁先执行
如果希望有规律的执行 就可以用线程通信
notify唤醒 wait等待
案例:两个方法交替
public class TestThread2 {public synchronized void print(){System.out.print("我");System.out.print("爱");System.out.print("学");System.out.print("习");System.out.println("-----------");this.notify();//唤醒正在等待的线程try {this.wait();//让当前线程等待 让出cpu执行权 进入就绪状态} catch (InterruptedException e) {throw new RuntimeException(e);}}public synchronized void show(){System.out.print("想");System.out.print("睡");System.out.print("觉");System.out.println("===========");this.notify();//唤醒正在等待的线程try {this.wait();//让当前线程等待 让出cpu执行权 进入就绪状态} catch (InterruptedException e) {throw new RuntimeException(e);}}
}
public static void main(String[] args) {TestThread2 tt2=new TestThread2();new Thread(){public void run(){while(true){ tt2.print();}}}.start();new Thread(){public void run(){while(true){ tt2.show();}}}.start();}
案例:三个和三个以上方法交替
public class TestThread3 {boolean b1=true;boolean b2=false;boolean b3=false;public synchronized void show1() {if (b3) {System.out.print("我");System.out.print("爱");System.out.print("学");System.out.print("习");System.out.println("-----------");}b1 = true;b3 = false;this.notifyAll();//唤醒所有正在等待的线程try {this.wait();//让当前线程等待 让出cpu执行权 进入就绪状态} catch (InterruptedException e) {throw new RuntimeException(e);}}public synchronized void show2(){if(b1){System.out.print("想");System.out.print("睡");System.out.print("觉");System.out.println("===========");}b2=true;b1=false;this.notifyAll();//唤醒所有正在等待的线程try {this.wait();//让当前线程等待 让出cpu执行权 进入就绪状态} catch (InterruptedException e) {throw new RuntimeException(e);}}public synchronized void show3(){if(b2){System.out.print("想");System.out.print("吃");System.out.print("饭");System.out.println("~~~~~~~~~~~");}b2=false;b3=true;this.notifyAll();//唤醒所有正在等待的线程try {this.wait();//让当前线程等待 让出cpu执行权 进入就绪状态} catch (InterruptedException e) {throw new RuntimeException(e);}}
}
public static void main(String[] args) {TestThread3 tt3=new TestThread3();new Thread(){public void run(){while(true){tt3.show1();}}}.start();new Thread(){public void run(){while(true){tt3.show2();}}}.start();new Thread(){public void run(){while(true){tt3.show3();}}}.start();}
wait和sleep区别
wait():释放锁 等待并释放锁让别的线程运行
sleep():不释放锁 在指定的时间抱着锁睡 时间一到马上醒来