网页策划书 网站建设定位,wordpress允许搜索,中国十大企业管理培训机构,高埗镇做网站第六章#xff1a;多线程
6.1#xff1a;程序、进程、线程基本概念 程序 程序program是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码#xff0c;静态对象。 进程 进程process是程序的一次执行过程#xff0c;或是正在运行的一个程序。是一个…第六章多线程
6.1程序、进程、线程基本概念 程序 程序program是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码静态对象。 进程 进程process是程序的一次执行过程或是正在运行的一个程序。是一个动态的过程有它自身的产生、存在和消亡的过程。【生命周期】 程序是静态的进程是动态的。进程作为资源分配的单位系统在运行时会为每个进程分配不同的内存区域。 线程 进程可进一步细化为线程是一个程序内部的一条执行路径。 若一个进行同一时间并行执行多个线程就是支持多线程的。线程作为调度和执行的单位每个线程拥有独立的运行栈和程序计数器(pc)线程切换的开销小。一个进程中的多个线程共享相同的内存单元/内存地址空间。他们从同一堆中分配对象可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但是多个线程操作共享的系统资源可能就会带来安全的隐患。 单核CPU和多核CPU的理解 单核CPU其实是一种假的多线程因为在一个时间单元内也只能执行一个线程的任务。如果是多核的话才能更好的发挥多线程的效率。一个Java应用程序java.exe其实至少有三个线程。main()主线程、gc()垃圾回收线程、异常处理线程。 并行与并发 并行多个CPU同时执行多个任务。 并发一个CPU(采用时间片)同时执行多个任务。 使用多线程的优点 提高应用程序的响应。对图形化界面更有意义可增强用户体验。提供计算机系统CPU的利用率。改善程序结构。将既长又复杂的进程分为多个线程独立运行利于理解和修改。 何时需要多线程 程序需要同时执行两个或多个任务。程序需要实现一些需要等待的任务时如用户输入、文件读写操作、网络操作、搜索等。需要一些后台运行的程序时。
6.2线程的创建和使用
Java语言的JVM允许程序运行多个线程它通过java.lang.Thread类来体现。 Thread类的特性 每个线程都是通过某个特定Thread对象的run()方法来完成操作的经常把run()方法的主体称为线程体。通过该Thread对象的start()方法来启动这个线程而非直接调用run()。 Thread类的构造器 Thread()创建新的Thread对象Thread(String threadname)创建线程并指定线程实例名。Thread(Runnable target)指定创建线程的目标对象它实现了Runnable接口中的run方法。Thread(Runnable target, String name)创建新的Thread对象。 多线程的创建一继承Thread类 创建一个继承与Thread类的子类。重写Thread类的run() ---- 将此线程执行的操作声明在run()中。创建Thread类的子类的对象。通过此对象调用start()。 // 1.创建一个继承与Thread类的子类。
class MyThread extends Thread{// 2.重写Thread类的run() public void run() {for(int i 0; i 100; i) {if(i % 2 0) {System.out.println(Thread.currentThread().getName() : i);}}}
}public class ThreadTest {public static void main(String[] args) {// 1.创建Thread类的子类的对象MyThread t1 new MyThread();// 2.通过此对象调用start()t1.start();}
}多线程的创建二实现Runnable接口 创建一个实现了Runnable接口的类。实现类去实现Runnable中的抽象方法run()创建实现类的对象。将此对象作为参数传递到Thread类的构造器中创建Thread类的对象。通过Thread类的对象调用start()。 // 1.创建一个实现了Runnable接口的类
class MThread implements Runnable {// 2.实现类去实现Runnable中的抽象方法run()public void run() {for(int i 0; i 100; i) {if(i % 2 0) {System.out.println(Thread.currentThread().getName() : i);}}}
}public class ThreadTest1 {public static void main(String[] args) {// 3.创建实现类的对象MThread mThread new MThread();// 4.将此对象作为参数传递到Thread类的构造器中创建Thread类的对象Thread t1 new Thread(mThread);// 5.通过Thread类的对象调用start()t1.start();}
}比较创建线程的两种方式 开发中优先选择实现Runnable接口的方式。原因 实现的方式没有类的单继承性的局限性。实现的方式更适合来处理多个线程有共享数据的情况。 联系public class Thread implememts Runnable相同点两种方式都需要重写run()将线程要执行的逻辑声明在run()中。 Thread中的常用方法 start()启动当前线程调用当前线程的run()。run()通常需要重写Thread类中的此方法将创建的线程要执行的操作声明在此方法中。currentThread()静态方法返回执行当前代码的线程。getName()获取当前线程的名字。setName()设置当前线程的名字。yield()释放当前cpu执行权。join()在线程a中调用线程b的join()此时线程a就进入阻塞状态知道线程b完全执行完以后线程a才结束阻塞状态。stop()已过时。当执行此方法时强制结束当前线程。isAlive()判断当前线程是否存活。 线程的优先级 MAX_PRIORITY: 10
MIN_PRIORITY: 1
NORM_PRIORITY: 5 -- 默认优先级如何获取和设置当前线程的优先级 getPriority()获取线程的优先级。setPriority(int p)设置线程的优先级。 说明 高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后低优先级的线程才执行。 线程的分类 Java中的线程分为两类一种是守护线程一种是用户线程。 它们在几乎每个方面都是相同的唯一的区别是判断JVM何时离开。守护是用来服务用户线程的通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程当前JVM将退出。
6.3线程的生命周期 JDK中用Thread.State类定义了线程的几种状态 想要实现多线程必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程在它的一个完整的生命周期中通常要经历如下的五种状态。 新建 当一个Thread或其子类的对象被声明并创建时新生的线程对象处于新建状态。 就绪 处于新建状态的线程被start()后将进入线程队列等待CPU时间片此时它已具备了运行的条件只是没分配到CPU资源。 运行 当就绪的线程被调度并获得CPU资源时便进入运行状态run()方法定义了线程的操作和功能。 阻塞 在某种特殊情况下被人为挂起或执行输入输出操作时让出CPU并临时中止自己的执行进入阻塞状态。 死亡 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。 线程的生命周期图解
6.4线程的同步 多线程出现了安全问题 问题的原因 当多条语句在操作同一个线程共享数据时一个线程对多条语句只执行了一部分还没有执行完另一个线程参与进来执行导致共享数据的错误。 解决办法 对多条操作共享数据的语句只能让一个线程都执行完在执行过程中其他线程不可以参与执行。Java对于多线程的安全问题提供了专业的解决方式同步机制。 方式一同步代码块 格式 synchronized(同步监视器) {// 需要被同步的代码
}操作共享数据的代码即为需要被同步的代码。 共享数据多个线程共同操作的变量。 同步监视器【俗称锁】。任何一个类的对象都可以充当锁。多个线程必须要共用同一把锁。 解决实现Runnable接口方式的线程安全问题 class Window1 implements Runnable {private int ticket 100;public void run() {while(true) {synchronized (this) {if (ticket 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() :买票票号为 ticket);ticket--;} else {break;}}}}
}public class WindowTest1 {public static void main(String[] args) {Window1 w new Window1();Thread t1 new Thread(w);Thread t2 new Thread(w);Thread t3 new Thread(w);t1.setName(窗口一);t2.setName(窗口二);t3.setName(窗口三);t1.start();t2.start();t3.start();}
}在实现Runnable接口创建多线程的方式中我们可以考虑使用this充当同步监视器。 解决继承Thread类方式的线程安全问题 class Window2 extends Thread {private static int ticket 100;public void run() {while(true) {synchronized(Window2.class) {if(ticket 0) {try{Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() 买票票号为 ticket);ticket--;} else {break;}}}}
}public class WindowTest2 {public static void main(String[] args) {Window2 t1 new Window2();Window2 t2 new Window2();Window2 t3 new Window2();t1.setName(窗口一);t2.setName(窗口二);t3.setName(窗口三);t1.start();t2.start();t3.start();}
}在继承Thread类创建多线程的方式中慎用this充当同步监视器考虑使用当前类充当同步监视器。 方式二同步方法 格式 权限修饰符 synchronized 返回值类型 方法名() {}如果操作共享数据的代码完整的声明在以方法中我们不妨将此方法声明为同步的。 同步方法仍然设计到同步监视只是不需要我们显式的声明。 非静态的同步方法同步监视器是this。静态的同步方式同步监视器是当前类本身。 解决实现Runnable接口方式的线程安全问题 class Window3 implements Runnable {private int ticket 100;public void run() {while(true) {show();}}private synchronized void show() {if (ticket 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() :买票票号为: ticket);ticket--;}}
}public class WindowTest3 {public static void main(String[] args) {Window3 w new Window3();Thread t1 new Thread(w);Thread t2 new Thread(w);Thread t3 new Thread(w);t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);t1.start();t2.start();t3.start();}
}解决继承Thread类方式的线程安全问题 class Window4 extends Thread {private static int ticket 100;public void run() {while(true) {show();}}public static synchronized void show() {if(ticket 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() 买票票号为 ticket);ticket--;}}
}public class WindowTest4 {public static void main(String[] args) {Window4 t1 new Window4();Window4 t2 new Window4();Window4 t3 new Window4();t1.setName(窗口1);t2.setName(窗口2);t3.setName(窗口3);t1.start();t2.start();t3.start();}
}方式三Lock(锁) 从JDK 5.0开始Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问每次只能有一个线程对Lock对象加锁线程开始访问共享资源之前应先获得Lock对象。ReentrantLock类实现了Lock它拥有synchronized相同的并发性和内存语义在实现线程安全的控制中比较常用的是ReentrantLock可以显示加锁、释放锁。 class Window implements Runnable {private int ticket 100;// 1.实例化ReentrantLockprivate ReentrantLock lock new ReentrantLock();public void run() {while(true) {try {// 2.调用锁定方法lock()lock.lock();if(ticket 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() :售票票号为 ticket);ticket--;} else {break;}} finally {// 3.调用解锁方法unlock()lock.unlock();}}}
}public class LockTest {public static void main(String[] args) {Window w new Window();Thread t1 new Thread(w);Thread t2 new Thread(w);Thread t3 new Thread(w);t1.setName(窗口一);t2.setName(窗口二);t3.setName(窗口三);t1.start();t2.start();t3.start();}
}synchronized与Lock的异同 相同点二者都可以解决线程安全问题。 不同点 synchronized机制在执行完相应的同步代码以后自动的释放同步监视器。Lock需要手动的启动同步lock()同时结束也需要手动的实现unlock()。 线程死锁 不同的线程分别占用对方需要的同步资源不放弃都在等待对方放弃自己需要的同步资源就形成了线程的死锁。 public class ThreadTest {public static void main(String[] args) {StringBuffer s1 new StringBuffer();StringBuffer s2 new StringBuffer();new Thread() {public void run() {synchronized(s1) {s1.append(a);s2.append(1);try{Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}synchronized (s2) {s1.append(b);s2.append(2);System.out.println(s1);System.out.println(s2);}}}}.start();new Thread(new Runnable() {public void run() {synchronized (s2) {s1.append(c);s2.append(3);try{Thread.sleep(100);}catch (InterruptedException e) {e.printStackTrace();}synchronized (s1) {s1.append(d);s2.append(4);System.out.println(s1);System.out.println(s2);}}}}).start();}
}出现死锁后不会出现异常不会出现提示只是所有的线程都处于阻塞状态无法继续。 解决方法 专门的算法、原则。尽量减少同步资源的定义。尽量避免嵌套同步。
6.5线程的通信 使用两个线程交替打印1-100 class Number implements Runnable {private int number 1;public void run() {while(true) {synchronized (this) {// 线程通信方法二notify();if(number 100) {System.out.println(Thread.currentThread().getName() : number);number;try{// 线程通信方法一wait();} catch (InterruptedException e) {e.printStackTrace();}} else {break;}}}}
}public class CommunicationTest {public static void main(String[] args){Number number new Number();Thread t1 new Thread(number);Thread t2 new Thread(number);t1.setName(线程1);t2.setName(线程2);t1.start();t2.start();}
}线程通信涉及到的方法 wait()一旦执行此方法当前线程就进入阻塞状态并释放同步监视器。notify()一旦执行此方法就会唤醒被wait的一个线程。如果有多个线程被wait就唤醒优先级高的那个。notifyAll()一旦执行此方法就会唤醒所有被wait的线程。 说明 wait()、notify()、notifyAll()这三个方法必须使用在同步代码块或同步方法中。wait()、notify()、notifyAll()这三个方法的调用这必须是同步代码块或同步方法中的同步监视器。否则会出现IllegalMonitorStateException异常。wait()、notify()、notifyAll()这三个方法是定义在java.lang.Object类中。 sleep()和wait()的异同 相同点 一旦执行方法都可以使得线程进入阻塞状态。 不同点 两个方法声明的位置不同Thread类中声明sleep()Object类中声明wait()。调用的要求不同sleep()可以在任何场景下调用。wait()必须使用在同步代码块或同步方法中。关于释放同步监视器如果两个方法都使用在同步代码块或同步方法中sleep()不会释放锁wait()会释放锁。
6.6JDK5.0新增线程创建方式 方式一实现Callable接口 与使用Runnable相比Callable功能更强大一些。 相比run()方法可以有返回值。方法可以抛出异常。支持泛型的返回值。 FutrueTask类 FutrueTask是Futrue接口的唯一实现类。FutrueTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行又可以作为Future得到Callable的返回值。 //1.创建一个实现Callable的实现类
class NumThread implements Callable{//2.实现call方法将此线程需要执行的操作声明在call()中Overridepublic Object call() throws Exception {int sum 0;for (int i 1; i 100; i) {if(i % 2 0){System.out.println(i);sum i;}}return sum;}
}public class ThreadNew {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread new NumThread();//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中创建FutureTask的对象FutureTask futureTask new FutureTask(numThread);//5.将FutureTask的对象作为参数传递到Thread类的构造器中创建Thread对象并调用start()new Thread(futureTask).start();try {//6.获取Callable中call方法的返回值//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。Object sum futureTask.get();System.out.println(总和为 sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}方式二使用线程池 背景 经常创建和销毁、使用量特别大的资源【并发情况下的线程】对性能影响很大。 思路 提前创建好多个线程放入线程池中使用时直接获取用完放回池中。可以避免频繁创建销毁、实现重复利用 好处 提高响应速度【减少了创建新线程的时间】。降低资源消耗【重复利用线程池中线程不需要每次都创建】。便于线程管理。 线程池相关API JDK 5.0起提供了线程池相关APIExecutoService和Executors。ExecutorService真正的线程池接口。常见子类ThreadPoolExecutor void execute(Runnable command)执行任务/命令没有返回值一般用来执行RunnableT FutureT submit(CallableT task)执行任务有返回值一般又来执行Callablevoid shutdown()关闭连接池 Executors工具类、线程池的工厂类用于创建并返回不同类型的线程池。 Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池Executors.newFixedThreadPool(n)创建一个可重用固定线程数的线程池Executors.newSingleThreadExecutor()创建一个只有一个线程的线程池Executors.newScheduledThreadPool(n)创建一个线程池它可安排在给定延迟后运行命令或定期执行 class NumberThread implements Runnable{Overridepublic void run() {for(int i 0;i 100;i){if(i % 2 0){System.out.println(Thread.currentThread().getName() : i);}}}
}public class ThreadPool {public static void main(String[] args) {//1. 提供指定线程数量的线程池ExecutorService service Executors.newFixedThreadPool(10);//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象service.execute(new NumberThread());//3.关闭连接池service.shutdown();}
}
