前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >Java并发编程之基础

Java并发编程之基础

作者头像
冬天vs不冷
发布于 2025-01-21 00:01:46
发布于 2025-01-21 00:01:46
7600
代码可运行
举报
文章被收录于专栏:springbootspringboot
运行总次数:0
代码可运行

1、线程与进程、并行并发、同步异步概念

1.1、进程与线程

  • 进程: 资源分配的最小单位(进程是线程的容器, 一个进程中包含多个线程, 真正执行任务的是线程
  • 线程: 资源调度的最小单位

进程

  • 程序由指令和数据组成,但是这些 指令要运行,数据要读写,就必须将指令加载到cpu,数据加载至内存。在指令运行过程中还需要用到磁盘,网络等设备,进程就是用来加载指令,管理内存,管理IO的
  • 当一个指令被运行,从磁盘加载这个程序的代码到内存,这时候就开启了一个进程
  • 进程就可以视为程序的一个实例,大部分程序都可以运行多个实例进程(例如记事本,浏览器等),部分只可以运行一个实例进程(例如360安全卫士)

线程

  • 一个进程之内可以分为多个线程
  • 一个线程就是一个指令流,将指令流中的一条条指令以一定的顺序交给 CPU 执行
  • Java 中,线程作为资源的最小调度单位,进程作为资源分配的最小单位。 在 windows 中进程是不活动的,只是作为线程的容器。

对比

  • 进程基本上相互独立的,而线程存在于进程内,是进程的一个子集
  • 进程拥有共享的资源,如内存空间等,供其内部的线程共享; 进程间通信较为复杂
  • 同一台计算机的进程通信称为 IPC(Inter-process communication)
  • 不同计算机之间的进程通信,需要通过网络,并遵守共同的协议,例如 HTTP
  • 线程通信相对简单,因为它们共享进程内的内存,一个例子是多个线程可以访问同一个共享变量
  • 线程更轻量,线程上下文切换成本一般上要比进程上下文切换低

1.2、 并行与并发

  • 并发: 在单核CPU下, 一定是并发执行的, 也就是在同一个时间段内一起执行. 实际还是串行执行, CPU的时间片切换非常快, 给人一种同时运行的感觉
  • 并行: 在多核CPU下, 能真正意义上实现并行执行, 在同一个时刻, 多个线程同时执行; 比如说2核cpu, 同时执行4个线程. 理论上同时可以有2个线程是并行执行的. 此时还是存在并发, 因为2个cpu也会同时切换不同的线程执行任务罢了

对比

  • 并发(concurrent): 是同一时间应对(dealing with)多件事情的能力
  • 并行(parallel): 是同一时间动手做(doing)多件事情的能力

1.3、同步和异步

  • 如果需要等待结果返回才能继续运行的话就是同步
  • 如果不需要等待就是异步

2、线程的创建

2.1、通过继承Thread创建线程

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class CreateThread {
	public static void main(String[] args) {
		Thread myThread = new MyThread();
        // 启动线程
		myThread.start();
	}
}

class MyThread extends Thread {
	@Override
	public void run() {
		System.out.println("my thread running...");
	}
}
  • 优点:使用继承方式的好处是,在run()方法内获取当前线程直接使用this就可以了,无须使用Thread.currentThread()方法
  • 缺点:Java不支持多继承,如果继承了Thread类,那么就不能再继承其他类。另外任务与代码没有分离,当多个线程执行一样的任务时需要多份任务代码

2.2、使用Runnable配合Thread

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test {
	public static void main(String[] args) {
		//创建线程任务
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println("Runnable running");
			}
		};
		//将Runnable对象传给Thread
		Thread t = new Thread(r);
		//启动线程
		t.start();
	}
}
  • 通过实现Runnable接口,并且实现run()方法。在创建线程时作为参数传入该类的实例即可

使用lambda表达式简化操作

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test {
	public static void main(String[] args) {
		//创建线程任务
		Runnable r = () -> {
            //直接写方法体即可
			System.out.println("Runnable running");
			System.out.println("Hello Thread");
		};
		//将Runnable对象传给Thread
		Thread t = new Thread(r);
		//启动线程
		t.start();
	}
}

2.3、使用FutureTask与Thread结合

使用FutureTask可以用泛型指定线程的返回值类型(Runnable的run方法没有返回值)

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test3 {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需要传入一个Callable对象
		FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
			@Override
			public Integer call() throws Exception {
				System.out.println("线程执行!");
				Thread.sleep(1000);
				return 100;
			}
		});

		Thread r1 = new Thread(task, "t2");
		r1.start();
		//获取线程中方法执行后的返回结果
		System.out.println(task.get());
	}
}

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class UseFutureTask {
   public static void main(String[] args) throws ExecutionException, InterruptedException {
      FutureTask<String> futureTask = new FutureTask<>(new MyCall());
      Thread thread = new Thread(futureTask);
      thread.start();
      // 获得线程运行后的返回值
      System.out.println(futureTask.get());
   }
}

class MyCall implements Callable<String> {
   @Override
   public String call() throws Exception {
      return "hello world";
   }
}

2.4、使用线程池来创建线程

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
/**
 * 创建线程的方式四:使用线程池
 *
 * 好处:
 * 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();
    }
}

3、线程运行原理

3.1、虚拟机栈与栈帧

虚拟机栈描述的是Java方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息,是属于线程的私有的。当Java中使用多线程时,每个线程都会维护它自己的栈帧!每个线程只能有一个活动栈帧(在栈顶),对应着当前正在执行的那个方法

3.2、线程上下文切换(Thread Context Switch)

因为以下一些原因导致 cpu 不再执行当前的线程,转而执行另一个线程

  • 线程的 cpu 时间片用完(每个线程轮流执行,看前面并行的概念)
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
  • 当Thread Context Switch发生时,需要由操作系统保存当前线程的状态,并恢复另一个线程的状态,Java 中对应的概念就是程序计数器(Program Counter Register),它的作用是记住下一条 jvm 指令的执行地址,是线程私有的
  • 线程的状态包括程序计数器、虚拟机栈中每个栈帧的信息,如局部变量、操作数栈、返回地址等
  • Context Switch 频繁发生会影响性能

3.3、Thread的常见方法

方法名

static

功能说明

注意

start()

启动一个新线程,在新的线程运行run方法中的代码

start方法只是让线程进入就绪,里面代码不一定立刻运行(CUP的诗句片还没分给它)。每个线程对象的start方法只能调用一次,如果调用多次会出现IllegalThreadStateException

run()

新线程启动后哦会调用的方法

如果在构造Thread对象时传递了Runnable参数,则线程启动后会调用Runnable中的run方法,否则默认不执行任何操作。但可以创建Thread的子类对象,来覆盖默认行为

join()

等待线程运行结束

join(long n)

等待线程运行结束,最多等待n毫秒

getId()

获取线程长整型的id

唯一id

getName()

获取线程名

setName(String)

修改线程名

getPriority()

获取线程优先级

setPriority(int)

修改线程优先级

java中规定线程优先级1~10的整数,较大的优先级能提高该线程被CUP调度的几率

getState()

获取线程状态

isInterrupted()

判断是否被打断

不会清除,打断标记(是否被线程打断过)

isAlive()

线程是否存活(还没有运行完毕)

interrupt()

打断线程

如果被打断线程正在sleep,wait,join会导致被打断的线程抛出InterruptedException,并清除打断标记;如果打断的正在运行的线程,则会设置打断标记;park的线程被打断,也会设置打断标记

interrupted()

static

判断当前线程是否被打断

会清除打断标记

currentThread()

static

获取当前正在执行的线程

3.4、sleep 与 yield

sleep方法

  • 调用 sleep() 会让当前线程从 Running(运行状态) 进入 Timed Waiting 状态(阻塞)
  • 其它线程可以使用interrupt 方法打断正在睡眠的线程,那么被打断的线程这时就会抛出 InterruptedException异常【注意:这里打断的是正在休眠的线程,而不是其它状态的线程】
  • 睡眠结束后的线程未必会立刻得到执行 (需要分配到cpu时间片)
  • 建议用 TimeUnit 的 sleep() 代替 Thread 的 sleep()来获得更好的可读性

yield方法

  • 调用 yield 会让当前线程从Running 进入 Runnable 就绪状态,然后调度执行其它线程
  • 具体的实现依赖于操作系统的任务调度器(cup重新选择,可以是其他线程,也可能还是自己)

3.5、线程优先级

线程优先级会提示(hint)调度器优先调度该线程,但它仅仅是一个提示,调度器可以忽略它, 如果 cpu 比较忙,那么优先级高的线程会获得更多的时间片,但 cpu 闲时,优先级几乎没作用

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
thread.setPriority(Thread.MAX_PRIORITY); //设置为优先级最高

3.6、 join方法

在主线程中调用t1.join,则主线程会等待t1线程执行完之后再继续执行

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    },"t1");
    t1.start();
    // t1.join(); 
    // 这里如果不加t1.join(), 此时主线程不会等待t1线程给r赋值, 主线程直接就输出r=0结束了
    // 如果加上t1.join(), 此时主线程会等待到t1线程执行完才会继续执行.(同步), 此时r=10;
    log.debug("结果为:{}", r);
    log.debug("结束");
}

3.7、interrupt 方法详解

  • 打断标记(是否被其他线程打断过),默认为false
  • 如果一个真正运行线程被打断,打断标记会被置为true
  • 如果是打断因sleep wait join方法而被阻塞的线程,打断标记会被置为false,抛异常

运行时打断示例

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    System.out.println("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        System.out.println("interrupt");
        t1.interrupt();
        System.out.println("打断标记为: "+t1.isInterrupted());
    }
}

结果:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
interrupt
打断标记为: true
被打断了, 退出循环

Process finished with exit code 0
  • 打断正常运行的线程, 线程并不会暂停
  • 被打断前Thread.currentThread().isInterrupted()的返回值为false,打断后返回值为true
  • 通过Thread.currentThread().isInterrupted()的返回值来手动停止线程

阻塞时打断示例

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        Thread.sleep(1000);
        System.out.println("iterrupt..");
        t1.interrupt();
        System.out.println(t1.isInterrupted()); // 如果是打断sleep,wait,join的线程, 即使打断了, 标记也为false
    }
}

结果:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
sleep...
iterrupt..
false
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.xc.day1.Test2.lambda$main$0(Test2.java:8)
	at java.lang.Thread.run(Thread.java:748)

Process finished with exit code 0

3.8、终止模式之两阶段终止模式

在一个线程T1中如何优雅终止线程T2?这里的优雅指的是给T2一个料理后事的机会。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        Monitor monitor = new Monitor();
        monitor.start();
        Thread.sleep(3500);
        monitor.stop();
    }
}

class Monitor {
    Thread monitor;
    /**
     * 启动监控器线程
     */
    public void start() {
        //设置线控器线程,用于监控线程状态
        monitor = new Thread(() -> {
            //开始不停的监控
            while (true) {
                Thread thread = Thread.currentThread();
                //判断当前线程是否被打断了
                if(thread.isInterrupted()) {
                    System.out.println("处理后续任务");
                    //终止线程执行
                    break;
                }
                System.out.println("监控器运行中...");
                try {
                    //线程休眠
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //如果是在休眠的时候被打断,不会将打断标记设置为true,这时要重新设置打断标记
                    thread.interrupt();
                }
            }
        });
        monitor.start();
    }
    /**
     * 	用于停止监控器线程
     */
    public void stop() {
        //打断线程
        monitor.interrupt();
    }
}

结果:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
监控器运行中...
监控器运行中...
监控器运行中...
监控器运行中...
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.xc.day1.Monitor.lambda$start$0(Test2.java:32)
	at java.lang.Thread.run(Thread.java:748)
处理后续任务

Process finished with exit code 0

3.9、sleep,yiled,wait,join 对比

  1. sleep,join,yield,interrupted是Thread类中的方法
  2. wait/notify是object中的方法
  3. sleep 不释放锁、释放cpu
  4. join 释放锁、抢占cpu
  5. yiled 不释放锁、释放cpu
  6. wait 释放锁、释放cpu

3.10、过时方法

不推荐使用的方法,这些方法已过时,容易破坏同步代码块,造成线程死锁。(原因:不释放锁)

方法名

功能说明

stop()

停止线程运行

suspend()

挂起(暂停)线程运行

resume()

恢复线程运行

3.11、守护线程

  • 当Java进程中有多个线程在执行时,只有当所有非守护线程都执行完毕后,Java进程才会结束
  • 但当非守护线程全部执行完毕后,守护线程无论是否执行完毕,也会一同结束。
  • 垃圾回收器线程就是一种守护线程

正常线程

  • main线程结束后,t1线程会在后台一直处于运行中
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test5 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {

            }
        },"t1");
        t1.start();
        System.out.println("main线程执行结束");
    }
}

守护线程

  • t1.setDaemon(true);将t1设置为守护线程
  • t1线程为守护线程,其他线程执行完,则t1被强制停止
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class Test5 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
            }
        },"t1");
        t1.setDaemon(true);
        t1.start();
        System.out.println("main线程执行结束");
    }
}

4、线程状态

4.1、五种状态

操作系统的层面上

  1. 初始状态,仅仅是在语言层面上创建了线程对象,即Thead thread = new Thead();,还未与操作系统线程关联
  2. 可运行状态,也称就绪状态,指该线程已经被创建,与操作系统相关联,等待cpu给它分配时间片就可运行
  3. 运行状态,指线程获取了CPU时间片,正在运行   1)当CPU时间片用完,线程会转换至【可运行状态】,等待 CPU再次分配时间片,会导致我们前面讲到的上下文切换
  4. 阻塞状态   1)如果调用了阻塞API,如BIO读写文件,那么线程实际上不会用到CPU,不会分配CPU时间片,会导致上下文切换,进入【阻塞状态】   2)等待BIO操作完毕,会由操作系统唤醒阻塞的线程,转换至【可运行状态】   3)与【可运行状态】的区别是,只要操作系统一直不唤醒线程,调度器就一直不会考虑调度它们,CPU就一直不会分配时间片
  5. 终止状态,表示线程已经执行完毕,生命周期已经结束,不会再转换为其它状态

4.2、六种状态

Thread.State 枚举,分为六种状态

新建状态、运行状态(就绪状态, 运行中状态)、阻塞状态、等待状态、定时等待状态、终止状态

  • NEW (新建状态) 线程刚被创建,但是还没有调用 start() 方法
  • RUNNABLE (运行状态) 当调用了 start() 方法之后,注意,Java API 层面的RUNNABLE 状态涵盖了操作系统层面的 【就绪状态】、【运行中状态】和【阻塞状态】(由于 BIO 导致的线程阻塞(线程等待io操作),在 Java 里无法区分,仍然认为 是可运行)
  • BLOCKED (阻塞状态) , WAITING (等待状态) , TIMED_WAITING(定时等待状态) 都是 Java API 层面对【阻塞状态】的细分,如线程等待io操作或等待cup分配时间片就为BLOCKED,sleep就为TIMED_WAITING, join为WAITING状态。后面会在状态转换一节详述。
  • TERMINATED (结束状态) 当线程代码运行结束
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class TestState {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread("t1") {	// new 状态
            @Override
            public void run() {
                System.out.println("running...");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable 状态

                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                System.out.println("running...");
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting 显示阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting 状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { // blocked 状态
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1 state "+t1.getState());
        System.out.println("t2 state "+t2.getState());
        System.out.println("t3 state "+t3.getState());
        System.out.println("t4 state "+t4.getState());
        System.out.println("t5 state "+t5.getState());
        System.out.println("t6 state "+t6.getState());
    }
}

结果:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
running...
t1 state NEW
t2 state RUNNABLE
t3 state TERMINATED
t4 state TIMED_WAITING
t5 state WAITING
t6 state BLOCKED
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2024-04-12,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
车联网?可不一定是IT巨头说了算
2015年,随着CES大会的热捧,“车联网”成为继互联网、物联网之后未来智能城市又一标志。汽车厂商巨头积极布局,奥迪、奔驰、宝马等均已推出各自的自动驾驶概念车;整车厂、零部件供应商结伴占位,芯片厂商英伟达在CES上发布了世界上第一款浮点运算能力超过1万亿次的移动芯片,试图通过超级移动芯片撬开智能汽车的大门。IT巨头同样不甘示弱,谷歌Android Auto和苹果CarPlay已然成为各家传统汽车厂商合作热点。而国内随着百度车联网战略正式发布。互联网BAT三巨头全部加入车联网系统争夺战中,但车联网这块蛋糕还真不一定是这些巨头们说了算。
曾响铃
2018/08/20
3950
无人驾驶大战新格局里,这些厂商卯足了劲……
无人驾驶汽车称得上是21世纪最有前景的科技进步。对于盲人等无法自己开车的人来说,这种技术将为其带来全新维度的自由,大幅扩大他们的活动范围。 正因如此,汽车领域的竞争才如此激烈。也正因如此,这场竞争才与科技历史上的其他革命性时刻如出一辙——至少能让我们想起当年的铁路大战。(有趣的是,当年也有另外一种形式的无人驾驶汽车。) ◎ Waymo(以前的谷歌) 当谷歌(现在的Alphabet)2009年启动无人驾驶汽车项目时,并未碰到任何竞争对手。 虽然目前仍然不能确保巨大成功,但现在可以明确的是,如今已经将无人驾
机器人网
2018/04/24
4860
无人驾驶大战新格局里,这些厂商卯足了劲……
闭门造车的苹果,究竟在造什么车?
从2014年起,苹果就一直在寻求制造自己的汽车。不过直到今天,人们也没有等到一辆苹果汽车的影子。
脑极体
2020/03/31
4020
11部委落章《智能汽车创新发展战略》,Apollo等智能驾驶进入快车道
近日,发改委、工信部等11个国家部委联合下发了“关于印发《智能汽车创新发展战略》的通知”(以下简称《战略》),虽然之前国家也出台过有关智能汽车的文件,但都是发展AI产业总体框架中的一部分,如今出台的《战略》则是我国针对智能汽车第一个国家级专项文件。
曾响铃
2020/03/04
3590
科技巨头造车,当务之急是跳出手机思维
智能汽车正在成为智能手机、可穿戴设备之后新的科技潮流。作为新一代汽车典范的特斯拉,这几年来一直是媒体宠儿;Apple、Google以及BAT等科技巨头,亦在汽车互联网上大费周章;传统汽车厂自然也不会坐视不管,纷纷寻求智能化的方法。然而,大家在如何让汽车变得更加智能上,却有不同思路。 为什么我们要让汽车智能化? 要回答哪种思路更具未来,我们先回答,为什么汽车要智能化? 要让汽车收集大数据,让汽车接入云服务,让汽车成为跑在路上的智能设备…这些都是企业思维,不少还是工程师思维:太多互联网产品的功能都是工程师觉得
罗超频道
2018/04/27
6480
科技巨头造车,当务之急是跳出手机思维
安卓蔑视汽车操作系统,为何阿里却对此兴趣盎然并押下重注?
2017年,不论是Google I/O大会还是苹果WWDC开发者大会,都表明人工智能成了巨头最青睐的概念。在Amazon Echo风靡全美之后,谷歌和苹果同时对“家”这个场景表达出前所未有的浓厚兴趣,先后推出了类似于Echo的家庭智能音响。而“汽车”这个曾经的热门概念,不论是谷歌还是苹果,都不再提。今年的WWDC只有苹果OS四件套:iOS、macOS、WatchOS、tvOS,Google I/O有AI、VR、智能家居,两个科技巨头都没有“上车”。 谷歌和宝马们对彼此变得很冷淡 将时钟拨回2014年,汽
罗超频道
2018/04/25
8330
安卓蔑视汽车操作系统,为何阿里却对此兴趣盎然并押下重注?
上汽、阿里结盟 打响“汽车互联”争夺战
业内人士认为,上汽与阿里巴巴合作之后,腾讯极有可能也去寻找大型汽车集团进行更深层次的战略合作,好戏还在后面。 互联网汽车大战打响! 近日,上汽集团与阿里巴巴集团在上海签署了“互联网汽车”战略合作协议,双方表示,将积极开展在“互联网汽车”和相关应用服务领域的合作,共同打造面向未来的“互联网汽车”及其生态圈。 上汽集团与阿里巴巴结盟之前,谷歌、微软等巨头,已经在全球范围展开与车企的合作,中国力量在汽车互联网时代面临缺席之考。然而,随着上汽和阿里巴巴战略协议的签署,中国最大汽车集团与中国最大互联网公司终于捆绑
大数据文摘
2018/05/22
5600
汽车厂商牵手科技巨头,到底谁傍谁?
随着无人驾驶技术关注度的提高,汽车厂商和科技公司正在各个层面上表现出前所未有的亲密关系。
科技云报道
2022/04/12
2720
汽车厂商牵手科技巨头,到底谁傍谁?
中国将为无人车路测开绿灯!智能时代来临,国内厂商迎来最好机会
企鹅号小编
2017/12/29
6270
中国将为无人车路测开绿灯!智能时代来临,国内厂商迎来最好机会
业界 | 自动驾驶战争:科技公司、车企和初创公司盘点
选自the Atlantic 机器之心编译 参与:李泽南、朱晓阳 自动驾驶距离我们的生活正越来越近,它会成为改变人类生活方式的新科技之一——不像硅谷每天讨论的「改变世界」那样虚幻,而是切实地引发一场革命。自动驾驶技术降低交通事故发生率,拯救生命的潜力让其具有的经济、文化和新美学意义变得不再那么重要。 在不久的将来,那些原本无法自由出行的人——如盲人将会因为自动驾驶的出现与社会接轨。自动驾驶汽车的大量部署将彻底打破原有交通运输体系,改变人们工作和城市出行的方式,进而改变城市的规划和连接形式。由此观之,自动驾
机器之心
2018/05/07
5340
业界 | 自动驾驶战争:科技公司、车企和初创公司盘点
2019智能交通年末盘点:领头羊百度Apollo开启“裂变模式”
不久前,百度Apollo完成了一次组织架构升级,除原有自动驾驶、车联网等业务组升级外,新增智能交通业务组,“专注交通基础设施智能化升级,为城市提供车路协同系统、区域智能信号优化系统等下一代智能交通解决方案”。
用户2908108
2019/12/23
7170
2019智能交通年末盘点:领头羊百度Apollo开启“裂变模式”
中国互联网巨头做汽车?与Tesla、无人驾驶汽车没多大关系
原创2015-03-24罗超 2015年伊始,汽车与互联网的结合似乎“又加快了步伐”。3月23日腾讯、富士康和和谐汽车达成“互联网+智能电动车”战略合作,三方将在河南郑州展开“互联网+智能电动车”领域的创新合作;同日,北京汽车与乐视控股在香港签订战略合作协议,共同打造互联网智能汽车生态系统。3月12日,阿里巴巴与上汽子公司宣布各出资5亿元成立互联网汽车研发公司,首款互联网汽车有望2016年上市。李彦宏在年初则透露百度无人驾驶汽车有望年底推出,并愿与汽车厂商开放合作。这几天智能电动车翘楚Tesla创始人Elo
罗超频道
2018/04/28
8510
中国互联网巨头做汽车?与Tesla、无人驾驶汽车没多大关系
【智驾周刊】Tesla员工公开反对自动驾驶激进策略 | NHTSA力挺自动驾驶:死个人算什么
2016.7.30 | Vol .9 AutoDriving Weekly 智能驾驶周刊,旨在汇聚智能驾驶领域一周要闻以及点评,供读者参考。内容包括喜闻乐见的新闻、大小企业的动向、关键技术的进展以及重要人物的消息等。 【政策】NHTSA力挺自动驾驶,死个人算什么 【一句话点评】看来Tesla这次不会Game Over,官方力挺还是挺有胆量的 美国汽车安全最高主管机关NHTSA(美国国家公路交通安全管理局)表示尽管特斯拉Model S车辆在启用Autopilot系统时发生了致死事件,但政府不会放弃加速
新智元
2018/03/27
7090
【智驾周刊】Tesla员工公开反对自动驾驶激进策略 | NHTSA力挺自动驾驶:死个人算什么
马云、李彦宏、贾跃亭、董明珠,科技大佬纷纷爱上造车,谁走得更顺?
印象中已是第六次参加广州车展,今年的广州车展科技元素比往年多了不少,许多汽车品牌都在强调自己的科技元素,比如雷克萨斯的辅助驾驶功能,全新宝马 1系运动轿车强调互联驾驶,上汽发布了包括MG ZS在内的三款互联网汽车……汽车与科技尤其是互联网正在加速结合,今年中国科技公司正在掀起一股“造车潮”,也反映了这样的趋势。 中国科技大佬的造车故事 说到造车的科技大佬,最近一段时间频繁刷屏的,有两个人。 一个是贾跃亭,激进推进造车战略使得乐视陷入一场前所未有的财务危机之中。在4月20日的乐视生态发布会上,我亲眼见到了可
罗超频道
2018/04/27
7780
马云、李彦宏、贾跃亭、董明珠,科技大佬纷纷爱上造车,谁走得更顺?
摩根大通唱好的“百度造车”,到底有哪些看点?
一向主张赋能的百度为何要下场造车,以及如何理性认识百度的造车计划,智能汽车会是百度汽车梦的全部吗?
Alter聊科技
2023/01/12
2850
车联网之战,BAT三家谁将胜出?
近日,腾讯宣布正式推出旗下车载开放平台,针对目前汽车行业车机系统的碎片化,提供一个标准接口,通过与硬件厂商合作的方式来整合产品,进军车联网。腾讯不仅开放了内容的服务API,还推出了包括车联ROM、车联
镁客网
2018/05/25
1.4K0
丰田和谷歌都要仰仗的自动驾驶霸主
来源:日经技术在线 丰田VS谷歌——随着自动驾驶实用化的临近,这场不同行业之间的对决成为了关注的焦点。在这场对决的背后,有一家汽车零部件厂商异军突起,成为自动驾驶时代的新主角。这就是德国的大陆集团(Continental)。该公司汽车相关业务的销售额,已经超过了十年前还是自己两倍之多的电装。这家有着140多年历史的老牌轮胎厂商,是如何转型成为高科技企业的呢?就让记者带您看看这家企业实际的经营情况。 大陆集团在日本的知名度不高,在汽车行业,很多人也只知道这是一家老牌轮胎企业。实际上,在自动驾驶系统领域,这家
新智元
2018/03/13
7180
丰田和谷歌都要仰仗的自动驾驶霸主
站在智能汽车时代即将来临的风口,传统图商该如何转型?
近日,百度地图与高德爆发了一场关于所处行业市场份额的口水战,将舆论的关注点聚焦至地图行业。而就在今日,另一家地图服务商巨头四维图新对外发布公告称,全资收购半导体公司杰发科技事项获得中国证监会无条件通过,又一次在行业内掀起波澜。 此时反观占据行业半壁江山的传统图商,在地图行业动静如此之大的情况下,却鲜有消息传出,这究竟为何? 互联网冲击下,传统图商市场份额被压榨的所剩无几 2014年以前,像高德和四维图新这样的企业还仅仅是提供专业地图数据的服务商,也就是传统图商。时至今日,随着互联网思维的日益崛起,从实力上来
镁客网
2018/05/29
4270
从充电到智能换电,看e换电怎么铺绿色出行这张“网”
2018年,特斯拉已经实现了每周量产超5000台的目标,还在上海落地建厂,蔚来汽车在纽交所上市开始缴费车辆,小鹏汽车完成了B+轮40亿元融资,以比亚迪、北汽新能源为代表的新能源汽车奔跑在中国各地的大街小巷。
镁客网
2018/12/28
1.3K0
从充电到智能换电,看e换电怎么铺绿色出行这张“网”
智能驾驶风口渐近 基金“掘金”步伐加快
企鹅号小编
2017/12/27
8270
推荐阅读
相关推荐
车联网?可不一定是IT巨头说了算
更多 >
目录
  • 1、线程与进程、并行并发、同步异步概念
    • 1.1、进程与线程
    • 1.2、 并行与并发
    • 1.3、同步和异步
  • 2、线程的创建
    • 2.1、通过继承Thread创建线程
    • 2.2、使用Runnable配合Thread
    • 2.3、使用FutureTask与Thread结合
    • 2.4、使用线程池来创建线程
  • 3、线程运行原理
    • 3.1、虚拟机栈与栈帧
    • 3.2、线程上下文切换(Thread Context Switch)
    • 3.3、Thread的常见方法
    • 3.4、sleep 与 yield
    • 3.5、线程优先级
    • 3.6、 join方法
    • 3.7、interrupt 方法详解
    • 3.8、终止模式之两阶段终止模式
    • 3.9、sleep,yiled,wait,join 对比
    • 3.10、过时方法
    • 3.11、守护线程
  • 4、线程状态
    • 4.1、五种状态
    • 4.2、六种状态
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档