谈谈多线程
package thread; /** * 线程 * 线程可以并发执行多段代码，给我们感觉上好像这些代码 * 在"同时运行"。 * * 创建线程有两种方式: * 方式一:继承Thread并重写run方法。 * @author ta * */ public class ThreadDemo1 { public static void main(String[] args) { MyThread1 t1 = new MyThread1(); MyThread2 t2 = new MyThread2(); /* * 启动线程要调用start方法，而不是直接调用线程 * 的run方法。 */ t1.start(); t2.start(); } } /** * 第一种创建线程的方式存在两个不足之处 * 1:由于java是单继承的，这导致继承了Thread后就不能再 * 继承其他类了。在实际开发中经常会继承某个超类来复 * 用其中的方法，这导致两者不能同时继承。 * * 2:继承线程后重写run方法来定义任务，这又导致我们将任 * 务直接定义在线程上，使得线程只能做该任务，无法并发 * 执行其他任务，重用性变差。 * @author ta * */ class MyThread1 extends Thread{ public void run() { for(int i=0;i<1000;i++) { System.out.println("你是谁啊?"); } } } class MyThread2 extends Thread{ public void run() { for(int i=0;i<1000;i++) { System.out.println("我是查水表的!"); } } }
package thread; /** * 第二种从创建线程的方式: * 实现Runnable接口，单独定义线程任务 * @author ta * */ public class ThreadDemo2 { public static void main(String[] args) { //实例化任务 Runnable r1 = new MyRunnable1(); Runnable r2 = new MyRunnable2(); //创建线程 Thread t1 = new Thread(r1); Thread t2 = new Thread(r2); t1.start(); t2.start(); } } class MyRunnable1 implements Runnable{ public void run() { for(int i=0;i<1000;i++) { System.out.println("你是谁啊?"); } } } class MyRunnable2 implements Runnable{ public void run() { for(int i=0;i<1000;i++) { System.out.println("我是查水表的!"); } } }
线程提供了一系列获取当前线程信息的方法
package thread; /** * 线程提供了一系列获取当前线程信息的方法 * @author ta * */ public class ThreadInfoDemo { public static void main(String[] args) { //获取主线程 Thread main = Thread.currentThread(); //获取线程的唯一标识 long id = main.getId(); System.out.println("id:"+id); //获取线程的名字 String name = main.getName(); System.out.println("name:"+name); //获取优先级 int priority = main.getPriority(); System.out.println("priority:"+priority); //显示是否处于活动状态 boolean isAlive = main.isAlive(); //显示是否为守护线程 boolean isDaemon = main.isDaemon(); //显示线程是否被中断 boolean isInterrupted = main.isInterrupted(); System.out.println("是否活着:"+isAlive); System.out.println("是否为守护线程:"+isDaemon); System.out.println("是否被中断:"+isInterrupted); } }
如何创建线程池
package thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 线程池 * 线程池是一个管理线程的机制。它主要解决两个问题: * 1:重用线程 * 2:控制线程数量 * 频繁的创建和销毁线程会给系统带来额外的开销，所以线程应当 * 得以重用。 * 当线程数量过多时，会出现资源消耗增大，CPU出现过度切换导致 * 并发性能降低。对此线程的数量也要得以控制在当前硬件环境所能 * 承受的范围内。 * * @author ta * */ public class ThreadPoolDemo { public static void main(String[] args) { ExecutorService threadPool = Executors.newFixedThreadPool(2); for(int i=0;i<5;i++){ Runnable r = new Runnable() { public void run() { Thread t = Thread.currentThread(); System.out.println(t.getName()+":正在执行任务..."); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println(t.getName()+":执行任务完毕..."); } }; //将任务交给线程池 threadPool.execute(r); System.out.println("将一个任务指派给了线程池!"); } // threadPool.shutdown();//不是立即关闭，只是不再接受新任务 // threadPool.shutdownNow();//立刻停止，任务没执行完都停 // System.out.println("线程池停止了!"); } }
关于线程安全问题
package thread; /** * 多线程并发的安全问题 * 当多个线程并发操作同一资源时，由于线程切换时机的不确定 * 和不可控，会导致操作该资源的代码逻辑执行顺序未按照设计 * 要求运行，出现了操作混乱。严重时可能导致系统瘫痪。 * @author ta * */ public class SyncDemo { public static void main(String[] args) { final Table table = new Table(); Thread t1 = new Thread() { public void run() { while(true) { int bean = table.getBean(); Thread.yield(); System.out.println(getName()+":"+bean); } } }; Thread t2 = new Thread() { public void run() { while(true) { int bean = table.getBean(); Thread.yield(); System.out.println(getName()+":"+bean); } } }; t1.start(); t2.start(); } } class Table{ //桌子上有20个豆子 private int beans = 20; /** * 解决并发安全问题的核心就是将多个线程抢着运行改为 * 有先后顺序的排队运行。 * Java提供了锁机制，强制多个线程同步运行一个方法 * * 当一个方法上使用关键字:synchronized修饰后，该方法 * 称为同步方法，多个线程不能同时在方法内部运行。 * @return */ public synchronized int getBean() { if(beans==0) { throw new RuntimeException("没有豆子了!"); } /* * yield方法会让运行这个方法的线程立刻让出CPU时间 * 在这里是为了模拟发生线程切换。 */ Thread.yield(); return beans--; } }
package thread; /** * 同步块 * 有效的缩小同步范围可以在保证并发安全的前提下尽可能 * 的提高并发效率。 * * 语法: * synchronized(同步监视器对象){ * 需用同步运行的代码片段 * } * @author ta * */ public class SyncDemo2 { public static void main(String[] args) { final Shop shop = new Shop(); Thread t1 = new Thread() { public void run() { shop.buy(); } }; Thread t2 = new Thread() { public void run() { shop.buy(); } }; t1.start(); t2.start(); } } class Shop{ /** * 直接在方法上使用synchroinzed，那么同步监视器 * 对象就是当前方法所属对象，即:方法中看到的this */ // public synchronized void buy() { public void buy() { try { Thread t = Thread.currentThread(); System.out.println(t.getName()+":正在挑衣服..."); Thread.sleep(5000); /* * 同步块有一个要求，多个线程看到的同步监视器 * 对象必须是同一个！否则没有同步运行效果。 * 具体使用哪个对象可以结合将来实际开发需求而定。 */ synchronized (this) { System.out.println(t.getName()+":正在试衣服..."); Thread.sleep(5000); } System.out.println(t.getName()+":结账离开"); } catch (Exception e) { } } }
package thread; /** * 静态方法若使用synchronized修饰后，那么一定具有同步 * 效果。 * @author ta * */ public class SyncDemo3 { public static void main(String[] args) { Thread t1 = new Thread() { public void run() { Boo.dosome(); } }; Thread t2 = new Thread() { public void run() { Boo.dosome(); } }; t1.start(); t2.start(); } } class Boo{ public synchronized static void dosome() { try { Thread t = Thread.currentThread(); System.out.println(t.getName()+":正在运行dosome方法"); Thread.sleep(5000); System.out.println(t.getName()+":运行dosome方法完毕"); } catch (Exception e) { e.printStackTrace(); } } }
互斥锁
package thread; /** * 互斥锁 * 当synchronized同时锁定多段代码片段时，并且他们指定 * 的同步监视器对象是[同一个]时,那么这些代码片段之间就 * 是互斥的，即:多个线程不能同时执行这些代码片段。 * @author ta * */ public class SyncDemo4 { public static void main(String[] args) { final Foo foo = new Foo(); Thread t1 = new Thread() { public void run() { foo.methodA(); } }; Thread t2 = new Thread() { public void run() { foo.methodB(); } }; t1.start(); t2.start(); } } class Foo{ public synchronized void methodA() { try { Thread t = Thread.currentThread(); System.out.println(t.getName()+":正在执行A方法..."); Thread.sleep(5000); System.out.println(t.getName()+":执行A方法完毕"); } catch (Exception e) { } } public void methodB() { synchronized (this) { try { Thread t = Thread.currentThread(); System.out.println(t.getName()+":正在执行B方法..."); Thread.sleep(5000); System.out.println(t.getName()+":执行B方法完毕"); } catch (Exception e) { } } } }
睡眠阻塞
package thread; import java.util.Scanner; /** * 睡眠阻塞 * * static void sleep(long ms) * 该方法会让运行这个方法的线程处于阻塞状态指定的毫秒， * 当超时后，线程会自动回到RUNNABLE状态，等待再次获取 * 时间片并发运行。 * * 注：一个线程进入阻塞状态时，CPU会立刻释放去并发执行 * 其他线程，直到该线程接触阻塞状态为止。 * @author ta * */ public class SleepDemo { public static void main(String[] args) { /* * 程序启动后，输入一个数字，如:100 * 然后每一秒钟递减一次并输出，到0时停止。 */ Scanner scanner = new Scanner(System.in); System.out.println("请输入一个数字:"); int num = Integer.parseInt(scanner.nextLine()); for(int i=num;i>0;i--) { System.out.println(i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("结束."); } }
package thread; /** * 当一个线程调用sleep方法处于阻塞状态时，其他线程调用 * 该线程的中断方法时，那么该线程的sleep方法会立即抛出 * 中断异常并打断睡眠阻塞。 * @author ta * */ public class SleepDemo2 { public static void main(String[] args) { /* * JDK8之前，有一个要求，即： * 当一个方法中的局部内部类想引用这个方法的其他 * 局部变量，那么这个变量必须是final的。 * 好比main方法中的局部内部类huang中的run方法里 * 引用了main方法的局部变量lin，那么这个变量就 * 必须声明为final的。 */ final Thread lin = new Thread() { public void run() { System.out.println("林:刚美完容,睡一会."); try { /* * 当一个线程调用sleep阻塞时，被其他线程 * 中断时会抛出中断异常 */ Thread.sleep(1000000); } catch (InterruptedException e) { System.out.println("林:干嘛呢!干嘛呢!干嘛呢!都破了相了!"); } System.out.println("林:醒了"); } }; Thread huang = new Thread() { public void run() { System.out.println("黄:开始砸墙!"); for(int i=0;i<5;i++) { System.out.println("黄:80!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } System.out.println("咣当!"); System.out.println("黄:搞定!"); //中断lin线程 lin.interrupt(); } }; lin.start(); huang.start(); } }
线程优先级
package thread; /** * 线程优先级 * * 线程无法主动获取CPU时间片，唯一可以干涉线程调度工作 * 的方式就是修改线程优先级，最大程度的改善获取CPU时间 * 片的几率。 * 理论上，线程优先级越高的线程获取CPU时间片的次数越多 * * 线程有10个优先级，分别用整数1-10表示。 * @author ta * */ public class PriorityDemo { public static void main(String[] args) { Thread max = new Thread() { public void run() { for(int i=0;i<10000;i++) { System.out.println("max"); } } }; Thread min = new Thread() { public void run() { for(int i=0;i<10000;i++) { System.out.println("min"); } } }; Thread norm = new Thread() { public void run() { for(int i=0;i<10000;i++) { System.out.println("nor"); } } }; max.setPriority(Thread.MAX_PRIORITY); min.setPriority(Thread.MIN_PRIORITY); min.start(); norm.start(); max.start(); } }
join方法
package thread; /** * join方法可以协调线程之间的同步运行 * * 异步运行:代码之间运行没有先后顺序，各干各的。 * 同步运行:代码运行有先后顺序。 * @author ta * */ public class JoinDemo { //标示图片是否下载完毕 public static boolean isFinish = false; public static void main(String[] args) { final Thread download = new Thread() { public void run() { System.out.println("down:开始下载图片..."); for(int i=1;i<=100;i++) { System.out.println("down:已下载"+i+"%"); try { Thread.sleep(50); } catch (InterruptedException e) { } } System.out.println("down:图片下载完毕!"); isFinish = true; } }; Thread show = new Thread() { public void run() { System.out.println("show:开始显示图片..."); /* * 先等在下载线程将图片下载完毕 */ try { /* * 当show线程调用download线程的join方法后就 * 进入了阻塞状态，直到download线程结束才会 * 解除阻塞。 */ download.join(); } catch (InterruptedException e) { } if(!isFinish) { throw new RuntimeException("图片加载失败!"); } System.out.println("show:显示图片完毕!"); } }; download.start(); show.start(); } }
守护线程
package thread; /** * 守护线程 * * 守护线程又称为后台线程，默认创建出来的线程都是普通 * 线程或称为前台线程。只有调用线程的setDaemon方法后 * 才会将该线程设置为守护线程。 * * 守护线程使用上与前台线程一样，但是在结束时机上有一点 * 不同:当进程结束时，所有正在运行的守护线程都会被强制 * 中断。 * 进程的结束:当一个进程中没有任何前台线程时即结束。 * * @author ta * */ public class DaemonThreadDemo { public static void main(String[] args) { Thread rose = new Thread() { public void run() { for(int i=0;i<5;i++) { System.out.println("rose:let me go!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } System.out.println("rose:啊啊啊啊啊AAAAAAaaaaa...."); System.out.println("噗通!"); } }; Thread jack = new Thread() { public void run() { while(true) { System.out.println("jack:you jump!i jump!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } } }; rose.start(); /* * 设置守护线程必须要在start方法之前进行。 */ jack.setDaemon(true); jack.start(); } }
static Thread currentThread()
package thread; /** * Thread提供了一个静态方法: * static Thread currentThread() * 该方法可以获取运行这个方法的线程。 * * 后期常用的一个API: ThreadLocal里面就会用到这个方法 * 来实现功能。 * @author ta * */ public class CurrentThreadDemo { public static void main(String[] args) { Thread main = Thread.currentThread(); System.out.println("运行main方法的线程是:"+main); Thread t = new Thread() { public void run() { Thread t = Thread.currentThread(); System.out.println("自定义线程:"+t); dosome(); } }; t.start(); dosome(); } public static void dosome() { Thread t = Thread.currentThread(); System.out.println("运行dosome方法的线程是:"+t); } }
