- 新建线程
新建线程很简单,只要使用new关键字创建一个线程对象.并且将它start()起来即可.那么线程start()后,会干什么呢?这才是问题的关键.线程Tread,有一个run()方法.start()方法就会新建一个线程并让这个线程执行run()方法
Thread t1 = new Thread(); t1.start();
这里要注意 下面的代码也能通过编译,也能正常运行.但是 却不能新建一个线程,而是在当前线程中调用run方法,只是当做一个普通方法调用
Thread t2 = new Thread(); t1.run();
注意:不要用run()方法来开启新线程.他只会在当前线程中,串行执行run()中的代码
创建线程的两种方法:
Thread t1 = new Thread() { @Override public void run() { System.out.println("Hello,I am 他"); } }; t1.start(); //Java8 版本 Thread t2 = new Thread(() -> System.out.println("Hello,I am 他")); t2.start(); public class CreateThread implements Runnable { public static void main(String[] args) { Thread t1 = new Thread(new CreateThread()); t1.start(); } /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see Thread#run() */ @Override public void run() { System.out.println("Oh, I am Runnable"); } }
下面的方法是最常用的!
- 终止线程
在jdk中 我们发现Thread提供了一个stop()方法,但是stop方法却被废弃了.原因是这个方法太过去暴力了.强行把执行到一半的线程终止.可能会引起一些数据不一致的问题.
因为他释放了这个线程所持有的所有锁,而这些锁恰恰是用来维持一个对象一致性的.例如写数据写到一半,并强行终止.那么对象就会被写坏.同时 由于锁已经被释放了,另一个等待的读线程顺理成章的读到了这个不一致的对象,悲剧也就发生了!
那如果需要停止一个线程时,其实方法很简单,.只需要由我们自行决定线程何时退出就可以了.
public class CreateThread implements Runnable { volatile boolean stopme = false; public void stopMe() { stopme = true; } @Override public void run() { while (true) { if (stopme) { System.out.println("exit by stop me"); break; } synchronized (u) { int v = (int) (System.currentTimeMillis() / 1000); u.setId(v); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } u.setName(String.valueOf(v)); } Thread.yield(); } } }
- 线程终端 在Java中 线程中断是一种重要的线程协作方式,从表面理解,中断就是让目标线程停止执行的意思,实际上并非完全如此,
严格意义上说, 线程中断并不是线程立即退出,而是给线程发送一个通知,告知目标线程,有人希望你退出啦.至于目标线程得到通知后如何处理,则完全由目标线程自行决定,这点很重要!
与线程中断有关的,有三个方法,
Thread t1 = new Thread(new CreateThread()); t1.interrupt();//中断线程 实例方法 t1.isInterrupted();//判断是否中断 实例方法 Thread.interrupted();//判断是否中断,并清除当前中断状态 静态方法 public class CreateThread implements Runnable { @Override public void run() { while (true) { if (Thread.currentThread().isInterrupted()) { System.out.println("Interrupted"); break; } try { Thread.sleep(2000);//实例线程 休眠2s 当线程休眠中被中断 抛出InterruptedException 异常 } catch (InterruptedException e) { System.out.println("Interrupted When Sleep"); Thread.currentThread().interrupt(); } Thread.yield(); } } public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new CreateThread()); t1.start(); Thread.sleep(1000);//main 休眠1s 后执行中断 t1.interrupt(); } }
- 等待(wait)和通知(notify)
为了支持多线程间的协作,JDK提供了两个非常重要的接口线程等待wait()方法和通知notify()方法,这两个方法并不是在Thread类中的 而是在Object类中,这意味着任何对象都可以调用这两个方法.
当在一个对象实例上调用wait()方法后,当前先吃就会在这个对象上等待,比如线程A中,调用了obj.wait()方法,那么线程A就会停止继续执行,而转为等待状态,等待何时结束呢?线程A会一直等到其他线程调用了obj.notify()方法为止,这时,obj对象就俨然成为了多线程之间通信的有效手段.
那wait()和notify()究竟是如何工作的呢?如果一个线程调用了object.wwait() 那么他就会进入object对象的等待队列,这个等待队列中,可能会有多个线程,因为系统运行多个线程同时等待一个对象.当object.notify()被调用时,他就会从这个等待队列中,随机选择一个线程,并将其唤醒,这个选择是不公平的,并不是先等待的线程就会优先选择,这个选择是完全随机的.
除了notify()方法外,Object对象还有一个类似的notifyAll()方法,.他和notify()的功能基本一样,区别在于他会唤醒等待队列中所有等待的线程,而不是随机的一个,
这里需要注意,Object.wait()方法并不是可以随便调用的.他必须包含在对应的synchronized语句中.无论是wait()和notify()都需要首先获得目标对象的一个监听器,
public class SimpleWN { final static Object object = new Object(); public static class T1 extends Thread { public void run() { synchronized (object) { System.out.println(System.currentTimeMillis() + ":T1 start!"); try { System.out.println(System.currentTimeMillis() + ":T1 wait for object "); object.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(System.currentTimeMillis() + ":T1 end! "); } } } public static class T2 extends Thread { public void run() { synchronized (object) { System.out.println(System.currentTimeMillis() + ":T2 start! notify one thread "); object.notify(); System.out.println(System.currentTimeMillis() + ":T2 end! "); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } } public static void main(String[] args) { Thread t1 = new T1(); Thread t2 = new T2(); t1.start(); t2.start(); } }
上述代码 开启了2个线程T1和T2,T1执行了wait(),注意 T1在执行等待之前,现获取了object对象锁,然后执行等待 T1会停下来等待,并释放对象锁,T2在执行notify()方法之前 获取object对象锁后,执行notify(),为了让效果明显.我们特意T2执行notify()后休眠2秒,,这样做可以明显了看出,T1得到通知后,还会先尝试重新获取对象锁,
注意 Object.wait()和Thread.sleep()两个方法都可以让线程等待若干时间.除了wait()可以被唤醒外,wait()执行完会释放目标对象的锁,而sleep()不会释放任何资源!
- 等待线程结束(join)和谦让(yield)
很多时候 一个线程的输入可能非常依然于另一个或者多个线程的输出.此时 这个线程就需要等待依赖线程执行完毕,才能继续执行,JDK提供了join()操作来实现这个功能,
public final synchronized void join(long millis)throws InterruptedException public final void join() throws InterruptedException
第一个方法给出了一个最大等待时间,如果超出给定时间目标线程还在执行,当前线程也会因为等待不及了,而继续执行下去 第二方法表示无线等待.它会阻塞当前线程,知道目标线程执行完毕.
下面提供一个简单的join实例,
public class JoinMain { public volatile static int i = 0; public static class AddThread extends Thread { public void run() { for (i = 0; i < 10000000; i++) ; } } public static void main(String[] args) throws InterruptedException { AddThread at = new AddThread(); at.start(); at.join(); System.out.println(i); } }
主函数中,如果不是用join()等待AddThread, 那么得到的i 很可能是0或者一个非常小的数字,但在join()后,表示主线程愿意等待AddThread执行完毕,跟着AddThread一起往前走,故在join()返回时.AddThread已经执行完了.故i 永远是10000000.
注意 不要在应用程序中 在Thread对象实例上使用类似wait()或者notify等方法, 因为折痕有可能会影响系统API的运行,或者被系统API所影响!
另外一个比较有趣的方法是Thread.yield();
public static native void yield();
这是一个静态方法,一旦执行,它会使当前线程让出CPU.当时注意,让出CPU并不代表当前线程不执行了.当前线程让出CPU后,还会进行CPU资源的争夺,但是是否能够再次被分配到,就不一定了,因此 对Thread.yield()的调用就好像在说:我已经完成一些最重要的工作 了.我应该休息一下了.可以给其他线程一些工作机会了!
如果你觉得一个线程不那么重要,或者优先级很低,而且害怕他会占用太多CPU资源,那么可以适当的时候调用这个方法,.给予其他重要的线程更多的工作机会!
- volatile Java使用了一些特殊的操作或者关键字来申明,告诉虚拟机,在这个地方,要尤其注意,不能随意变动优化目标指令. 易变得 不稳定的.
当你用volatile声明一个变量时,就等于告诉虚拟机,这个变量极有可能会被某些程序或者线程修改.为了确保可见性,虚拟机做了特殊的手段,保证这个变量的可见性!