1.1,多线程的作用:

  *线程是程序执行的一条路径, 一个进程中可以包含多条线程
  *多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.2,多线程的应用场景:

  * 红蜘蛛同时共享屏幕给多个电脑
  * 迅雷开启多条线程一起下载
  * QQ同时和多个人一起视频
  * 服务器同时处理多个客户端请求

1.3,线程并发与并行的区别:

  * 并发是指两个任务都请求运行,而处理器只能按受一个任务,就把这两个任务安排轮流进行,由于时间间隔较短,使人感觉两个任务都在运行。
  * 并行就是两个任务同时运行,就是甲任务进行的同时,乙任务也在进行。(需要多核CPU)
  * 如果用一台电脑我先给甲发个消息,然后立刻再给乙发消息,然后再跟甲聊,再跟乙聊。这就叫并发。
  * 比如我跟两个网友聊天,左手操作一个电脑跟甲聊,同时右手用另一台电脑跟乙聊天,这就叫并行。

1.4,线程的生命周期:

新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();

就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;

运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就     绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同,阻塞状态又可以分为三种:

1.等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

1.5,线程的三种创建方式:

1.5.1,继承Thread类,重写run方法:

 public class Demo01_Thread {
public static void main(String[] args) {
MyThread mh = new MyThread(); //4.创建Thread类的子类对象
mh.start(); //5.开启线程
}
}
class MyThread extends Thread{ //1.继承Thread
@Override
public void run() { //2.重写run方法
for (int i = ; i < ; i++) { //3.将要执行的代码写在run方法中
System.out.println(getName+"继承线程已执行"+i);
}
}
}

  如上图所示,创建MyThread实例进入新建状态,然后调用start()方法启动,但是线程不一定会立马启动,因为要看cpu的资源分配

1.5.2,实现Runnable,重写run方法:

     public static void main(String[] args) {
MyRunnable mr = new MyRunnable(); //4.创建Runnable中的子类实例
Thread tr = new Thread(mr); //将Runnable中的子类变量放入Thread类中
tr.start();
}
}
class MyRunnable implements Runnable{ //1.定义类实现Runnable @Override
public void run() {
for (int i = ; i < ; i++) { //2.重写Run方法
System.out.println(Thread.currentThread().getName()+"Runnable中的线程执行:"+i); //3.将要执行代码写在run方法中
}
}
}

1.5.3,继承Thread与Runnable有什么区别:

  源码的区别:  

  * a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
  * b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

  总结的好处与坏处:

  * 继承Thread                       * 实现Runnable接口
  * 好处是:可以直接使用Thread类中的方法,代码简单        * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  * 弊端是:如果已经有了父类,就不能用这种方法           * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

1.6,实现Callable创建线程(了解就好,弊处代码太复杂一般不用):

         // 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(); // 可以执行Runnable对象或者Callable对象代表的线程
Future<Integer> f1 = pool.submit(new MyCallable());
Future<Integer> f2 = pool.submit(new MyCallable()); // V get()
Integer i1 = f1.get();
Integer i2 = f2.get(); System.out.println(i1);
System.out.println(i2); // 结束
pool.shutdown(); public class MyCallable implements Callable<Integer> { private int number; public MyCallable(int number) {
this.number = number;
} @Override
public Integer call() throws Exception {
int sum = ;
for (int x = ; x <= number; x++) {
sum += x;
}
return sum;
} }

上面是线程的作用,以及五种状态的详细讲解还有线程的创建方式,下面是对线程进行的一些操作。


1.7,多线程之同步代码块:

  什么情况下需要同步?
  * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
  * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

  同步代码块?
  * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
  * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

1.7.1,非静态方法使用锁让代码进行同步,锁对象可以是任意对象,只要相同就好:

     class Printer {
Demo d = new Demo();
public static 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 static void print2() {
synchronized(d){
System.out.print("噢");
System.out.print("我");
System.out.print("不");
System.out.print("信");
System.out.print("\r\n");
}
}
}

1.7.2,静态方法使用锁,让代码进行同步:

         class Printer {
public static void print1() {
synchronized(Printer.class){ //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
System.out.print("黑");
System.out.print("马");
System.out.print("程");
System.out.print("序");
System.out.print("员");
System.out.print("\r\n");
}
}
/*
* 非静态同步函数的锁是:this
* 静态的同步函数的锁是:字节码对象
*/
public static synchronized void print2() {
System.out.print("传");
System.out.print("智");
System.out.print("播");
System.out.print("客");
System.out.print("\r\n");
}
}

1.8,多线程之多线程休眠(顾名思义就是休眠线程的):

  * Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

     public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = ; i < ; i++) {
try {
Thread.sleep();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getName()+"aaaaaaaaaaaa");
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i = ; i < ; i++) {
try {
Thread.sleep();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getName()+"bb");
}
}
}.start();
}
}

1.9,多线程之守护线程:

  *setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出

     Thread t1 = new Thread() {
public void run() {
for(int i = ; i < ; i++) {
System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}; Thread t2 = new Thread() {
public void run() {
for(int i = ; i < ; i++) {
System.out.println(getName() + "...bb");
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}; t1.setDaemon(true); //将t1设置为守护线程 t1.start();
t2.start();

2.0,多线程之加入线程:

  * join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
  * join(int), 可以等待指定的毫秒之后继续

 final Thread t1 = new Thread() {
public void run() {
for(int i = ; i < ; i++) {
System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
try {
Thread.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}; Thread t2 = new Thread() {
public void run() {
for(int i = ; i < ; i++) {
if(i == ) {
try {
//t1.join(); //插队,加入
t1.join(); //加入,有固定的时间,过了固定时间,继续交替执行
Thread.sleep();
} catch (InterruptedException e) { e.printStackTrace();
}
}
System.out.println(getName() + "...bb"); }
}
}; t1.start();
t2.start();

2.1,多线程之礼让线程(了解):

     public static void main(String[] args) {
new MyTread().start();
new MyTread().start(); }
}
class MyTread extends Thread{
@Override
public void run() {
for (int i = ; i < ; i++) {
if(i % == ){
Thread.yield();//让出cpu
}
System.out.println(getName()+"..."+i);
}
}
}

2.2,多线程之设置线程的优先级(了解):

     public static void main(String[] args) {
Thread t1 = new Thread(){
public void run() {
for (int i = ; i < ; i++) {
System.out.println(getName()+"aaaaaaaaaaaaa\t\t\t"+i);
}
};
}; Thread t2 = new Thread(){
public void run() {
for (int i = ; i < ; i++) {
System.out.println(getName()+"bb\t\t\t"+i);
}
};
};
// t1.setPriority(10); //设置最大优先级
// t2.setPriority(1);
t2.setPriority(Thread.MIN_PRIORITY); //最小
t1.setPriority(Thread.MAX_PRIORITY); //最大
t1.start();
t2.start();
}
}

2.3,多线程之死锁(了解)

  * 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
  * 尽量不要嵌套使用

             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();
}

2.4,多线程(两个线程间的通信)(掌握):

  * 1.什么时候需要通信
  * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
  * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
  * 2.怎么通信
  * 如果希望线程等待, 就调用wait()
  * 如果希望唤醒等待的线程, 就调用notify();
  * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

     public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(){
@Override
public void run() {
while(true){
try {
mt.print1();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start(); new Thread(){
@Override
public void run() {
while(true){
try {
mt.print2();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start();
}
}
class MyThread{
int flag =;
public void print1() throws InterruptedException{
synchronized(this){
if(flag !=){ //当前线程等待
this.wait();
}
System.out.print("第一个线程~");
System.out.print("\r\n");
flag = ;
this.notify(); //随机唤醒等待的线程
}
}
public void print2() throws InterruptedException{ synchronized(this){
if(flag !=){
this.wait();
}
System.out.print("第二个线程~");
System.out.print("\r\n");
flag = ;
this.notify();
}
}
}

2.5,多线程(三个或三个以上间的线程通信):

  * 多个线程通信的问题
  * notify()方法是随机唤醒一个线程
  * notifyAll()方法是唤醒所有线程
  * JDK5之前无法唤醒指定的一个线程
  * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

  

     public static void main(String[] args) {
MyThread1 mt = new MyThread1();
new Thread(){
@Override
public void run() {
while(true){
try {
mt.print1();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start(); new Thread(){
@Override
public void run() {
while(true){
try {
mt.print2();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start();
new Thread(){
@Override
public void run() {
while(true){
try {
mt.print3();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}.start();
}
}
class MyThread1{
int flag =;
public void print1() throws InterruptedException{
synchronized(this){
while(flag !=){ //当前线程等待
this.wait();
}
System.out.print("第一条线程~");
System.out.print("\r\n");
flag = ;
// this.notify(); //随机唤醒等待的线程
this.notifyAll(); //唤醒全部~
}
}
public void print2() throws InterruptedException{ synchronized(this){
while(flag !=){
this.wait();
}
System.out.print("第二条线程~");
System.out.print("\r\n");
flag = ;
// this.notify();
this.notifyAll(); //唤醒全部~
}
} public void print3() throws InterruptedException{ synchronized(this){
while(flag !=){ //线程3再次等待,if语句是在那里等待就在那里起来
this.wait();
}
System.out.print("第三条线程~");
System.out.print("\r\n");
flag = ;
// this.notify();
this.notifyAll(); //唤醒全部~
}
}
}

2.6,JDK1.5的新特性互斥锁)(掌握):

  * 1.同步
  * 使用ReentrantLock类的lock()和unlock()方法进行同步
  * 2.通信
  * 使用ReentrantLock类的newCondition()方法可以获取Condition对象
  * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
  * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

     public static void main(String[] args) {
MyThread2 mt = new MyThread2();
new Thread(){
public void run(){
while(true){
try {
mt.print1();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}.start();
new Thread(){
public void run(){
while(true){
try {
mt.print2();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}.start(); new Thread(){
public void run(){
while(true){
try {
mt.print3();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}.start();
}
}
class MyThread2{
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition();
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition(); private int flag =;
public void print1() throws InterruptedException{
r.lock(); //获取锁
if(flag !=){
c1.await(); //await线程等待
}
System.out.print("第一条线程~");
System.out.print("\r\n");
flag = ;
c2.signal(); //线程唤醒
r.unlock();//释放锁
}
public void print2() throws InterruptedException{
r.lock();
if(flag !=){
c2.await();
}
System.out.print("第二条线程~");
System.out.print("\r\n");
flag = ;
c3.signal();
r.unlock();
} public void print3() throws InterruptedException{
r.lock();
if(flag !=){
c3.await();
}
System.out.print("第三条线程~");
System.out.print("\r\n");
flag = ;
c1.signal();
r.unlock();
}
}

2.7_多线程(线程组的概述和使用)(了解):

  * A:线程组概述
  * Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
  * 默认情况下,所有的线程都属于主线程组。
  * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
  * public final String getName()//通过线程组对象获取他组的名字
  * 我们也可以给线程设置分组
  * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
  * 2,创建线程对象
  * 3,Thread(ThreadGroup?group, Runnable?target, String?name)
  * 4,设置整组的优先级或者守护线程
  * B:案例演示
  * 线程组的使用,默认是主线程组

     public static void main(String[] args) {
// demo1();
ThreadGroup tg = new ThreadGroup("我是一个新的线程组"); //创建新的线程组
MyThread4 mt = new MyThread4(); //创建Runnable的子类对象
Thread m1 = new Thread(tg, mt,"张三"); //将线程m1放在族中
Thread m2 = new Thread(tg, mt,"李四"); //将线程m1放在族中
System.out.println(m1.getThreadGroup().getName()); //获取组名
System.out.println(m2.getThreadGroup().getName()); } private static void demo1() {
MyThread4 mt = new MyThread4(); Thread m1 = new Thread(mt,"张三");
Thread m2 = new Thread(mt,"李四");
ThreadGroup tg1 =m1.getThreadGroup();
ThreadGroup tg2 =m2.getThreadGroup();
System.out.println(tg1.getName());
System.out.println(tg2.getName());
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
for (int i = ; i < ; i++) {
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}

2.8_多线程(线程池的概述和使用)(了解):

  * A:线程池概述
  * 程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
  * B:内置线程池的使用概述
  * JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
  * public static ExecutorService newFixedThreadPool(int nThreads)
  * public static ExecutorService newSingleThreadExecutor()

     public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(); //创建一个线程池,可容纳俩线程
pool.submit(new MyThread4()); //把线程放入线程池中
pool.submit(new MyThread4());
pool.shutdown();//关闭线程池
}
}

java高级之多线程的更多相关文章

  1. JAVA高级之路----JAVA多线程

    介绍 这段时间一直在学习和整理一些通往java高级程序猿必备的知识点,有些是工作中必须要知道的,有些是面试必须要知道的, 但是不管怎么样,学习了就不会有坏处,不可能全部记得住,最起码得雁过留痕,知识不 ...

  2. [Java面经]干货整理, Java面试题(覆盖Java基础,Java高级,JavaEE,数据库,设计模式等)

    如若转载请注明出处: http://www.cnblogs.com/wang-meng/p/5898837.html   谢谢.上一篇发了一个找工作的面经, 找工作不宜, 希望这一篇的内容能够帮助到大 ...

  3. Java高级之线程同步

    本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处! 关于实现多线程的意义,"从业四年看并发"一文已经讲述,而本篇主要讲一下常用的设计 ...

  4. Java高级软件工程师面试考纲(转)

    如果要应聘高级开发工程师职务,仅仅懂得Java的基础知识是远远不够的,还必须懂得常用数据结构.算法.网络.操作系统等知识.因此本文不会讲解具体的技术,笔者综合自己应聘各大公司的经历,整理了一份大公司对 ...

  5. Java高级软件工程师面试考纲

    如果要应聘高级开发工程师职务,仅仅懂得Java的基础知识是远远不够的,还必须懂得常用数据结构.算法.网络.操作系统等知识.因此本文不会讲解具体的技术,笔者综合自己应聘各大公司的经历,整理了一份大公司对 ...

  6. 转载:[Java面经]干货整理, Java面试题(覆盖Java基础,Java高级,JavaEE,数据库,设计模式等)

    原文:http://www.cnblogs.com/wang-meng/p/5898837.html 一:继承.抽象类与接口区别.访问控制(private, public, protected,默认) ...

  7. 面试 Java 高级后端开发,要准备哪些知识点?

    其实公司肯花时间让你去面试,前提条件一定是通过你的简历,一定发现了你和公司的匹配点,也就是说,一定是有录用意向的. 在技术面试的时间段里(最长1个小时),你如果能展现你的优势那是最好的,但如果你做不到 ...

  8. Java高级面试题解析(一)

    最近,在看一些java高级面试题,我发现我在认真研究一个面试题的时候,我自己的收获是很大的,我们在看看面试题的时候,不仅仅要看这个问题本身,还要看这个问题的衍生问题,一个问题有些时候可能是一个问题群( ...

  9. 成为java高级程序员需要掌握哪些

    section 1 1.Core Java,就是Java基础.JDK的类库,很多童鞋都会说,JDK我懂,但是懂还不足够,知其然还要知其所以然,JDK的源代码写的非常好,要经常查看,对使用频繁的类,比如 ...

随机推荐

  1. java_变量和常量

    一.变量(可以改变的量) 1.命名规则: a.遵循标识符命名规则: 1.关键字是不能用作标识符的 2.区分大小写 3.可以包含数字.字母.下划线.美元符号$,但是不能以数字作为开头 b.尽量使用有意义 ...

  2. linux-2.6.38 input子系统(简析)

    一.输入子系统简介 引入输入子系统这种机制可以对不同的输入设备进行管理.各种输入设备如:鼠标.键盘.触摸屏等有一套相同的处理机制,输入子系统将其共性提取出来, 对于驱动开发人员只用实现其差异即可,实现 ...

  3. LocalDateTime、LocalDate、Long、Date、String 相互转换

    DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); ...

  4. python3:iterable, iterator, generator,抽象基类, itertools的使用。

    目录: iterable对象 iterator对象, 数据类型Iterator类 数据类型Generator类. 生成器表达式 collections.abc:容器的抽象基类.用于判断具体类. ite ...

  5. LVM卷管理

    一.LVM是做什么的 LVM ( Logical Volume Manager ,逻辑卷管理器)LVM 是建立在磁盘和分区之上的一个逻辑层,用来提高磁盘分区管理的灵活性.LVM 可以对磁盘分区按照组的 ...

  6. vs调试代码 提示 未能加载文件或程序集“Oracle.DataAccess”或它的某一个依赖项。试图加载格式不正确的程序。

    未能加载文件或程序集“Oracle.DataAccess”或它的某一个依赖项.试图加载格式不正确的程序. 1.调试-选项-项目和解决方案-web项目-勾选对网站和项目使用iis express 64 ...

  7. PHP mysqli_fetch_field() 函数

    返回结果集中下一字段(列),然后输出每个字段名称.表格和最大长度: <?php // 假定数据库用户名:root,密码:123456,数据库:RUNOOB $con=mysqli_connect ...

  8. 小米oj 重拍数组求最大和

     重排数组求最大和 序号:#34难度:困难时间限制:1000ms内存限制:10M 描述 假设有一个n元素的数组(数组的元素索引从1开始),针对这个数组有q个查询请求,每个请求由一对整数li,ri组成, ...

  9. UVALive 7178 Irrational Roots 多项式的根

    题意:给你一个首项为1的n阶方程(n<=8),求出方程的无理数的根: #include <cstdio> #include <iostream> #include < ...

  10. 初学c++动态联编

    先看一下什么是C++联编? 我觉得通俗的讲,用对象来访问类的成员函数就是静态联编. 那什么是动态联编: 一般是通过虚函数实现动态联编. 看一个动态联编的例子: 我比较懒,所以直接粘贴了MOOC视频的图 ...