并行 就是两个任务同时运行,就是甲任务进行的同时,乙任务也在进行。(需要多核CPU) 并发是指两个任务都请求运行,而处理器只能按受一个任务,就把这两个任务安排轮流进行,由于时间间隔较短,使人感觉两个任务都在运行。 比如我跟两个网友聊天,左手操作一个电脑跟甲聊,同时右手用另一台电脑跟乙聊天,这就叫并行。 如果用一台电脑我先给甲发个消息,然后立刻再给乙发消息,然后再跟甲聊,再跟乙聊。这就叫并发。
Java命令会启动java虚拟机,启动JVM,等于启动了一个应用程序,也就是启动了一个进程。该进程会自动启动一个 “主线程” ,然后主线程去调用某个类的 main 方法。JVM的启动至少启动了垃圾回收线程和主线程,所以是多线程的。
方式一:继承Thread
定义类继承Thread重写run方法把新线程要做的事写在run方法中创建线程对象开启新线程, 内部会自动执行run方法(start()方法) public static void main(String[] args) { MyThread myThread =new MyThread(); //创建Thread类的子类对象 //myThread.run(); myThread.start(); for (int i = 0; i < 1000; i++) { System.out.println("yyy"); } } } class MyThread extends Thread{ //1,继承Thread public void run() { //2.重写run方法 for (int i = 0; i < 1000; i++) {//3.将要执行的代码写在run方法中 System.out.println("xx"); } }效果如下:(此时 x和 y 会不定时的相互输出) 方式二:实现Runnable 定义类实现Runnable接口
实现run方法把新线程要做的事写在run方法中创建自定义的Runnable的子类对象创建Thread对象, 传入Runnable调用start()开启新线程, 内部会自动调用Runnable的run()方法 public static void main(String[] args) { MyRunable myRunable =new MyRunable(); //4.创建Runnable的子类对象 Thread thread =new Thread(myRunable); //5.将其当作参数传递给Thread的构造函数 thread.start(); //开启线程 for (int i = 0; i < 1000; i++) { //3.将要执行的代码卸载run方法中 System.out.println("b"); } } } class MyRunable implements Runnable{ //1.定义一个类实现Runnable @Override public void run() { //2.重写run方法 for (int i = 0; i < 1000; i++) { //3.将要执行的代码卸载run方法中 System.out.println("a"); } }效果如下:
角度一:(查看源码的区别)
方式一:继承Thread :
由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法方式二:实现Runnable :
构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法角度二:
方式一:继承Thread
好处是:可以直接使用Thread类中的方法,代码简单弊端是:如果已经有了父类,就不能用这种方法方式二:实现Runnable接口
好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂。方式一:继承Thread类
new Thread() { //1.继承Thread类 public void run() { //2.重写run方法 for (int i = 0; i < 1000; i++) { //3.将要执行的代码写在run方法中 System.out.println("a"); } } }.start(); //4.开启线程方式二:实现Runnable接口
new Thread(new Runnable() { //1.将Runable的子类对象传递给Thread的构造方法 public void run() { //2.重写run方法 for (int i = 0; i < 1000; i++) { //3.将要执行的代码写在run方法中 System.out.println("b"); } } }).start(); //4.开启线程线程也是可以获得名字和设置名字的 1.获取名字
通过getName()方法获取线程对象的名字2.设置名字
通过构造函数可以传入String类型的名字方式一:设置名字可以通过构造方法去实现
new Thread("线程a") { //构造方法实现设置线程名字 public void run() { System.out.println(this.getName()+"a"); } }.start(); new Thread("线程b") { //构造方法实现设置线程名字 public void run() { System.out.println(this.getName()+"b"); } }.start(); }效果如下: 方式二:
new Thread() { public void run() { this.setName("线程c");//设置线程名 System.out.println(this.getName()+" a"); } }.start(); new Thread() { public void run() { this.setName("线程d");//设置线程名 System.out.println(this.getName()+" b"); } }.start();效果如下: 方式三:(整个花括号代表子类对象)
Thread t1= new Thread() { public void run() { this.setName("线程c"); System.out.println(this.getName()+" a"); } }; Thread t2= new Thread() { public void run() { this.setName("线程d"); System.out.println(this.getName()+" b"); } }; t1.setName("线程c"); t2.setName("线程d");Thread.currentThread获取当前正在执行的线程
new Thread() { public void run() { System.out.println(this.getName()+" a"); } }.start(); new Thread(new Runnable() { @Override public void run() { //Thread.currentThread获取当前正在执行的线程 System.out.println(Thread.currentThread().getName()+" a"); } }).start(); Thread.currentThread().setName("我是主线程"); System.out.println(Thread.currentThread().getName()); }效果如下:
顾名思义,就是让线程睡一会儿。慢一点执行。因为计算机CPU执行速度很快。输出结果可能几纳秒就计算结束。休眠线程可以理解为让当前线程睡一会。执行慢一点。 Thread.sleep(毫秒,纳秒),控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
public static void main(String[] args) throws InterruptedException { for (int i = 20; i >=0; i--) { Thread.sleep(1000); System.out.println("倒计时第"+i+"秒"); } }效果如下:此时每一秒都会执行一次线程。
new Thread() { public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(this.getName()+ " a"); } } }.start(); new Thread(new Runnable() { public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+" b"); } } }).start();上面这段代码是用runnable接口实现一个线程在书写一遍。
setDaemon(),设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出。
Thread t1=new Thread() { public void run() { for (int i = 0; i < 2; i++) { System.out.println(getName()+" a"); } } }; Thread t2=new Thread() { public void run() { for (int i = 0; i < 50; i++) { System.out.println(getName()+" b"); } } }; t2.setDaemon(true); //当传入true意味着设置为守护线程 t1.start(); t2.start();效果如下: 此时我们会发现,当我们线程0执行两次,线程1依旧执行了6次。很好理解。理论上当我们用QQ给别人发送文件时,我们关闭聊天窗口,这时传送数据应该会立即执行关闭。但是,当我们关闭聊天窗口,传送文件的这个线程,依旧在执行。这就是所谓的延迟缓冲效果。QQ聊天窗口与传送文件就是守护与被守护的关系
相当于插队
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续join(int), 可以等待指定的毫秒之后继续 public static void main(String[] args) { final Thread t1=new Thread() { public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+" aaaaaa"); } } }; Thread t2=new Thread() { public void run() { for (int i = 0; i < 10; i++) { if (i==2) { try { //t1.join(); t1.join(1); //插队指定的使劲,过了指定时间后,两条线程交替执行 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(getName()+" bbbbbbbb"); } } }; t1.start(); t2.start(); }效果如下: 此时我们会发现,当我们不传入参数的时候,线程1在执行两次输出b的时候,线程0会优先插队进入在进行1之后。当我们传入参数的时候,意思就是进行0会执行多少毫秒。比如,当i=2的时候,进程0会优先执行1毫秒。 并且注意此时的t1的作用范围是final,因为花括号表示一个局部的作用范围。所以并不能将t1运用到t2的作用范围之中
yield让出cpu,当前线程会暂定让出CPU。给别的进程进行执行。
public static void main(String[] args) { new MyThread().start(); new MyThread().start(); } } class MyThread extends Thread{ public void run() { for (int i = 0; i <=1000; i++) { if (i%10==0) { Thread.yield(); //让出CPU } System.out.println(getName()+" "+i); } }效果如下: 当某一线程达到10的时候,会进行将CPU让出给另外一个线程去执行。
setPriority() 设置线程的优先级。java中最小线程的级别是1,最高级别的线程是10。不去设置线程的话,它的优先级别就是5.
public final static int MIN_PRIORITY = 1//源码中设置最小的优先级是1 public final static int NORM_PRIORITY = 5;//源码中设置普通优先级是5 public final static int MAX_PRIORITY = 10;//源码中设置最大的优先级是10 Thread t1=new Thread() { public void run() { for (int i = 0; i < 1000; i++) { System.out.println(getName()+" a"); } } }; Thread t2=new Thread() { public void run() { for (int i = 0; i < 1000; i++) { System.out.println(getName()+" b"); } } }; t1.setPriority(10); t1.setPriority(Thread.MAX_PRIORITY); t2.setPriority(1); t2.setPriority(Thread.MIN_PRIORITY); ///两种写法一个即可 t1.start(); t2.start();效果如下: 线程0也就是输出a的明显比线程1也就是输出b的要多得多,因为优先级别比较高
1.什么情况下需要同步
当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.2.同步代码块
使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块。多个同步代码块如果使用相同的锁对象, 那么他们就是同步的 未使用synchronized之前 final Printer printer=new Printer(); new Thread() { public void run(){ while (true) { printer.print1(); } } }.start(); new Thread() { public void run(){ while (true) { printer.print2(); } } }.start(); } } class Printer{ public void print1(){ System.out.print("我"); System.out.print("是"); System.out.print("小"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } public void print2(){ System.out.print("我"); System.out.print("是"); System.out.print("大"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); }此时我们可能会出现断续的情况,也就是输出会进行插叙。是因为当我们执行print1()的时候,CPU可能会抢占资源,使用print2()方法。此时,我们希望在输出print1的时候,print2不进行输出。这就需要运用到同步机制。
public static void main(String[] args) { final Printer printer=new Printer(); new Thread() { public void run(){ while (true) { printer.print1(); } } }.start(); new Thread() { public void run(){ while (true) { printer.print2(); } } }.start(); } } class Printer{ Demo d =new Demo(); public void print1(){ synchronized (d) { //同步代码块,锁机制,锁对象可以是任意的 System.out.print("我"); System.out.print("是"); System.out.print("小"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } } public void print2(){ synchronized (d) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象 System.out.print("我"); System.out.print("是"); System.out.print("大"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } } } class Demo{ //锁对象 }注意几点: 第一:我们在最后需要设置一个任意的对象,把他当作一种锁,以此这样来实现进程同步。 第二我们设置锁锁对象不能用匿名对象(new Object()),因为匿名对象不是同一个对象。
使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的 同步方法只需要在方法上加synchronized关键字即可 非静态同步方法:
class Printer2{ Demo d =new Demo(); //非静态的同步方法的锁对象是什么? //答:非静态的同步方法的锁对象是this public synchronized void print1(){ //同步方法只需要在方法上加synchronized关键字即可 System.out.print("我"); System.out.print("是"); System.out.print("小"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } public void print2(){ synchronized (this){ System.out.print("我"); System.out.print("是"); System.out.print("大"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } } }问:非静态的同步方法的锁对象是什么? 答:非静态的同步方法的锁对象是this 静态同步方法:
class Printer2{ Demo d =new Demo(); //静态的同步方法的锁对象是什么?? //是该类的字节码对象 public static synchronized void print1(){ //同步方法只需要在方法上加synchronized关键字即可 System.out.print("我"); System.out.print("是"); System.out.print("小"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } public void print2(){ synchronized (Printer2.class){ System.out.print("我"); System.out.print("是"); System.out.print("大"); System.out.print("学"); System.out.print("生"); System.out.print("\r\n"); } } }问:静态的同步方法的锁对象是什么?? 答:是该类的字节码对象
我们通过一个案例来体现该问题,需求:铁路售票,一共100张,,通过四个窗口卖完 方法一: Thread方法
主函数:开启四个线程 public static void main(String[] args) { // TODO Auto-generated method stub new Ticket().start(); new Ticket().start(); new Ticket().start(); new Ticket().start(); }车票类方法
class Ticket extends Thread{ private static int ticket =100; public void run() { while (true) { synchronized (Ticket.class) { if (ticket <= 0) { break; } try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(getName()+"------这是第"+ticket--+"号票"); } } }细节太多建议反复观看,
首先ticket为什么要设置static,因为有四个线程对同一个数据进行处理。所以数据要进行统一,否则创建四个线程,每个线程票数都会是从100开始。其次,我们需要票数判断中进行synchronized 该处我们需要对票数进行同步,因为我们想要实现多进行对一个数据进行改变的时候,需要进行同步。否则ticket会在进行赋值和自减之间出现问题。我们的锁使用的是Ticket.class 如果我们使用this关键字,那么不会进行同步,因为Thread有4个对象。方法二:火车站卖票的例子用实现Runnable接口
public static void main(String[] args) { MyTicket myTicket=new MyTicket(); new Thread(myTicket).start(); new Thread(myTicket).start(); new Thread(myTicket).start(); new Thread(myTicket).start(); }车牌类方法
class MyTicket implements Runnable{ private int tickets =100; @Override public void run() { // TODO Auto-generated method stub while (true) { synchronized (this) { if (tickets<=0) { break; } try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"这是第"+tickets--+"号票"); } }细节太多,建议反复观看
此处的tickets的票数并没有设置静态的原因是我们的runable接口创建线程,不需要创建四个对象。将本身当作资源传递给Thread的构造函数new Thread(myTicket).start()。锁对象可不可以用this。因为我们只创建了一个对象,this 表示的就是 myTicket我们对哲学家问题进行思考
private static String s1="筷子左"; private static String s2="筷子右"; public static void main(String[] args) { new Thread() { public void run() { while (true) { synchronized (s1) { System.out.println(getName()+"获取"+s1+"等待"+s2); }synchronized (s2) { System.out.println(getName()+"拿到"+s2+"等待"+"开吃"); } } } }.start(); new Thread() { public void run() { while (true) { synchronized (s2) { System.out.println(getName()+"获取"+s2+"等待"+s1); }synchronized (s1) { System.out.println(getName()+"拿到"+s1+"等待"+"开吃"); } } } }.start(); }这两个线程发生死锁,原因是第一个线程有左筷子之后有拿到右筷子开吃。此时第二个进程有右筷子,但是他又申请左筷子。此时,他们都抢占这右筷子。谁也不让谁。
回顾以前说过的线程安全问题,我们可以看以前的集合以及String类都有设置线程安全或不安全的代码
看源码:Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)Vector是线程安全的,ArrayList是线程不安全的StringBuffer是线程安全的,StringBuilder是线程不安全的Hashtable是线程安全的,HashMap是线程不安全的