程序进程线程
Posted lemonzhang
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了程序进程线程相关的知识，希望对你有一定的参考价值。
1、程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
2、进程(process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。—生命周期
1）进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
3、线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
1）若一个进程同一时间并行执行多个线程，就是支持多线程的
2）线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
3）一个进程中的多个线程共享相同的内存单元/内存地址空间?它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行与并发：
1) 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
2) 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。
多线程程序的优点：
1) 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2) 提高计算机系统CPU的利用率
3) 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程
1）程序需要同时执行两个或多个任务。
2）程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3）需要一些后台运行的程序时。
线程的创建和启动
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread 类来体现。
1）每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
2）通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
Thread类构造器
1）Thread()：创建新的Thread对象；
2）Thread(String threadname)：创建线程并指定线程实例名；
3）Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法；
4）Thread(Runnable target, String name)：创建新的Thread对象。
API中创建线程的两种方式
JDK1.5之前创建新执行线程有两种方法：
1）继承Thread类的方式；
2）实现Runnable接口的方式；
1）：继承Thread类
1) 定义子类继承Thread类。 2) 子类中重写Thread类中的run方法。 3) 创建Thread子类对象，即创建了线程对象。 4) 调用线程对象start方法：启动线程，调用run方法。
package com.thread.test; public class ThreadTest { public static void main(String[] args) { //3 创建Thread子类对象，即创建了线程对象。 MyThread m=new MyThread(); //4 调用线程对象start方法：启动线程，调用run方法。 m.start(); } } //1 定义子类继承Thread类。 class MyThread extends Thread{ //2 子类中重写Thread类中的run方法。 @Override public void run(){ for (int i = 0; i <100 ; i++) { System.out.println("子线程"+i); } } }
2）：实现Runnable接口
1) 定义子类，实现Runnable接口。 2) 子类中重写Runnable接口中的run方法。 3) 通过Thread类含参构造器创建线程对象。 4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。 5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
package com.thread.test; public class ThreadTest { public static void main(String[] args) { // 3) 通过Thread类含参构造器创建线程对象。------------------------------创建实现类的对象 // 4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。-------将此对象作为参数传递Thread类构造器中，创建Thread类的对象 // 5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。---通过Thread类的对象调用start(); new Thread(new MyThread2()).start(); } } // 1) 定义子类，实现Runnable接口。 class MyThread2 implements Runnable{ //2) 子类中重写Runnable接口中的run方法。 @Override public void run() { for (int i = 0; i <100 ; i++) { System.out.println("子线程"+i); } } }
Thread类的有关方法
void start(): 启动线程，并执行对象的run()方法 ? run(): 线程在被调度时执行的操作 ? String getName(): 返回线程的名称 ? void setName(String name):设置该线程名称 ? static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类 static void yield()：线程让步 ? 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程 ? 若队列中没有同优先级的线程，忽略此方法 ? join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将 被阻塞，直到 join() 方法加入的 join 线程执行完为止 ? 低优先级的线程也可以获得执行 ? static void sleep(long millis)：(指定时间:毫秒) ? 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后 重排队。 ? 抛出InterruptedException异常 ? stop(): 强制线程生命期结束，不推荐使用 ? boolean isAlive()：返回boolean，判断线程是否还活着
线程的调度
1）调度策略
2）调度方法
1.同优先级线程组成先进先出队列（先到先服务），使用时间片策略
2.对高优先级，使用优先调度的抢占式策略
3）线程的优先级
1.等级，方法
MAX_PRIORITY：10 ? MIN _PRIORITY：1 ? NORM_PRIORITY：5
getPriority() ：返回线程优先值 ?
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级 ?
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
Java中的线程分为两类：一种是守护线程，一种是用户线程。
守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
线程的生命周期
多线程出现了安全问题
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。
线程的同步：Synchronized同步机制
同步机制中的锁：
在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防 止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法 就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须 锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁 之时，另一个任务就可以锁定并使用它了。
synchronized的锁是什么？ ?
任意对象都可以作为同步锁。
所有对象都自动含有单一的锁（监视器）。 ?
同步方法的锁：静态方法（类名.class）、非静态方法（this） ?
同步代码块：自己指定，很多时候也是指定为this或类名.class
必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就 无法保证共享资源的安全 ?
1）同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），
2）同步代码块（指定需谨慎）。对于实现 Runnable 接口的方法，由于就一个实现类对象，所以可以用this 当锁。 对于继承Thread 类的方法，由于有多个子类的实例，所以需要使用 类名.class 当锁。
同步的方式，解决了线程的安全问题。---好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性
线程的通信：
* 涉及到的三个方法：
* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
* notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
* notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
*
* 说明：
* 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
* 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
* 否则，会出现IllegalMonitorStateException异常
* 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
*
* 面试题：sleep() 和 wait()的异同？
* 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
* 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
* 2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
* 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
package com.company; // * 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印 public class Comm { public static void main(String[] args) { CommThread th=new CommThread(); Thread t1=new Thread(th,"线程1"); Thread t2=new Thread(th,"线程2"); t1.start(); t2.start(); } } class CommThread implements Runnable{ private int count=100; private Object ob=new Object(); @Override public void run() { while (true) { synchronized (ob) { ob.notify(); if(count>0) { System.out.println("xincheng"+Thread.currentThread().getName()+":"+count); count--; try { ob.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } else { break; } } } } }
* 解决线程安全问题的方式三：Lock锁 --- JDK5.0新增
*
* 1. 面试题：synchronized 与 Lock的异同？
* 相同：二者都可以解决线程安全问题
* 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
* Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
*
* 2.优先使用顺序：
* Lock ? 同步代码块（已经进入了方法体，分配了相应资源） ? 同步方法（在方法体之外）
*
*
* 面试题：如何解决线程安全问题？有几种方式
package com.company; import java.util.concurrent.locks.ReentrantLock; public class MainLock { public static void main(String[] args) { Test th=new Test(); Thread t1=new Thread(th,"窗口1"); Thread t2=new Thread(th,"窗口2"); Thread t3=new Thread(th,"窗口3"); t1.start(); t2.start(); t3.start(); } } class Test implements Runnable{ private int ticket=100; ////1.实例化ReentrantLock private ReentrantLock Lock=new ReentrantLock(); @Override public void run() { while (true) { ////2.调用锁定方法lock() Lock.lock(); try { { if(ticket>0){ System.out.println(Thread.currentThread().getName()+"买票："+ticket); ticket--; } else { break; } } } finally { // //3.调用解锁方法：unlock() Lock.unlock(); } } } }
package com.company; /* * 线程通信的应用：经典例题：生产者/消费者问题 * * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品， * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员 * 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品 * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 * * 分析： * 1. 是否是多线程问题？是，生产者线程，消费者线程 * 2. 是否有共享数据？是，店员（或产品） * 3. 如何解决线程的安全问题？同步机制,有三种方法 * 4. 是否涉及线程的通信？是*/ public class Product { public static void main(String[] args) { Clerk clerk=new Clerk(); Producer p1=new Producer(clerk); Consumer c1=new Consumer(clerk); p1.start(); c1.start(); } } //共享数据可以认为是Clerk或者producecount class Clerk{ private int producecount=0; public synchronized void produceProduct(){ if(producecount<20) { producecount++; System.out.println(Thread.currentThread().getName()+":生产"+producecount); notify(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void comsumProduct(){ if(producecount>0) { producecount--; System.out.println(Thread.currentThread().getName()+":消费"+producecount); notify(); } else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } //生产者线程 class Producer extends Thread{ private Clerk clerk; public Producer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { System.out.println(getName() + ":开始生产产品....."); while (true) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } clerk.produceProduct(); } } } //消费者的线程 class Consumer extends Thread{ private Clerk clerk; public Consumer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { System.out.println(getName() + ":开始消费产品....."); while (true) { try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } clerk.comsumProduct(); } } }
* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
//1.创建一个实现Callable的实现类 class NumThread implements Callable{ //2.实现call方法，将此线程需要执行的操作声明在call()中 @Override public 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(); } } }
* 创建线程的方式四：使用线程池
*
* 好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理
* corePoolSize：核心池的大小
* maximumPoolSize：最大线程数
* keepAliveTime：线程没有任务时最多保持多长时间后会终止
class NumberThread implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } class NumberThread1 implements Runnable{ @Override public 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); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的属性 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适合适用于Runnable service.execute(new NumberThread1());//适合适用于Runnable // service.submit(Callable callable);//适合使用于Callable //3.关闭连接池 service.shutdown(); } }
以上是关于程序进程线程的主要内容，如果未能解决你的问题，请参考以下文章