java多线程能超过cpu核心数吗 java多线程能不能利用多核

方式一：继承Thread类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法:启动线程，调用run方法。

示例代码如下：

1 packagecom.hd.thread1;2
3 /**
4 * 多线程的创建5 * 方式一：继承Thread类6 * 1、创建一个继承Thread类的子类7 * 2、重写Thread类的run()方法8 * 3、创建Thread类的子类对象9 * 4、通过此对象调用start()10 *11 * 例子：遍历100以内的偶数12 *13 */
14
15 //1、创建一个继承Thread类的子类
16 class MyThread extendsThread {17
18 //2、重写Thread类的run()方法
19 @Override20 public voidrun() {21 for(int i = 0; i < 100; i ++) {22 if(i % 2 == 0) {23 System.out.println(Thread.currentThread().getName() + "---" +i);24 }25 }26 }27
28 }29
30
31 public classThreadTest1 {32 public static voidmain(String[] args) {33 //3、创建Thread类的子类对象
34 MyThread myThread = newMyThread();35
36 //4、通过此对象调用start():37 //1) 启动该线程38 //2)调用当前线程的run()方法
39 myThread.start();40
41 //问题一：直接调用run()方法，程序会当作普通方法执行，不会启动另外一个线程42 //myThread.run();43
44 //问题二：2次调用start()方法，不可以让已经start()线程去执行，回报异常IllegalThreadStateException，线程状态不对45 //myThread.start();
46
47 System.out.println(Thread.currentThread().getName() + "---" + "Hello World");48 }49 }

注意点:

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。

想要启动多线程，必须调用start方法。

一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。

方式二：实现Runnable接口

1) 定义子类，实现Runnable接口。

2) 子类中重写Runnable接口中的run方法。

3) 创建实现类的对象。

4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

5) 调用Thread类对象的start方法:开启线程，调用Runnable子类接口的run方法。

代码示例

1 packagecom.hd.thread1;2
3 /**
4 * 创建多线程的方式二：实现Runnable接口5 * 1、创建一个实现类Runnable接口的类6 * 2、实现类去实现Runnable中的抽象方法：run()7 * 3、创建实现类的对象8 * 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类对象9 * 5、通过Thread类的对象调用start()10 *11 *12 * 比较创建线程的两种方式(Thread和Runnable)13 * 开发中：优先选择：实现Runnable接口的方式14 * 原因：1、实现的方式没有类的单继承性的局限性15 * 2、实现的方式更适合来处理多个线程有共享数据的情况16 *17 * 联系：Thread类也实现类Runnable接口18 * 相同点：两种方式都需要重写run()，将线程的执行逻辑声明在run()中19 *20 */
21 //1、创建一个实现类Runnable接口的类
22 class MyRunnable implementsRunnable {23 //2、实现类去实现Runnable中的抽象方法：run()
24 @Override25 public voidrun() {26 for (int i = 0; i < 100; i++) {27 if(i % 2 == 0) {28 System.out.println(Thread.currentThread().getName() + " : " +i);29 }30 }31 }32
33 }34
35 public classThreadTest2{36
37 public static voidmain(String[] args) {38 //3、创建实现类的对象
39 MyRunnable myRunnable = newMyRunnable();40 //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
41 Thread t = newThread(myRunnable);42 //5、通过Thread类的对象调用start()
43 t.start();44 }45 }

继承方式和实现方式的联系与区别

联系：Thread类也实现类Runnable接口

相同点：两种方式都需要重写run()，将线程的执行逻辑声明在run()中

区别两种方式(Thread和Runnable)

开发中：优先选择：实现Runnable接口的方式

原因：　1、实现的方式没有类的单继承性的局限性

2、实现的方式更适合来处理多个线程有共享数据的情况

方式三：实现Callable接口的方式

1、创建一个实现Callable的实现类

2、实现call方法，将此线程需要执行的操作声明在call()中

3、创建Callable接口实现类的对象

4、将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象

5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法

6、通过FutureTask的对象的get()方法，获取Callable中的call方法的返回值

代码如下：

1 /**
2 * 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增3 *4 * 1、创建一个实现Callable的实现类5 * 2、实现call方法，将此线程需要执行的操作声明在call()中6 * 3、创建Callable接口实现类的对象7 * 4、将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象8 * 5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法9 * 6、通过FutureTask的对象的get()方法，获取Callable中的call方法的返回值10 *11 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？12 * 1、call()可以有返回值的13 * 2、call()可以抛出异常，被外面的操作捕获，获取异常的信息14 * 3、Callable是支持范型的15 */
16 //1、创建一个实现Callable的实现类
17 class NumThread implementsCallable {18 //2、实现call方法，将此线程需要执行的操作声明在call()中
19 @Override20 public Object call() throwsException {21 int sum = 0;22 for (int i = 1; i <= 100; i++) {23 if (i % 2 == 0) {24 System.out.println(i);25 sum +=i;26
27 }28 }29 returnsum;30 }31 }32
33 public classThreadNew {34 public static voidmain(String[] args) {35 //3、创建Callable接口实现类的对象
36 NumThread numThread = newNumThread();37 //4、将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
38 FutureTask futureTask = newFutureTask(numThread);39 //5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
40 newThread(futureTask).start();41 try{42 //6、通过FutureTask的对象的get()方法，获取Callable中的call方法的返回值43 //get()方法的返回值即为FutureTask构成器参数Callable实现类重写的call()的返回值
44 Object sum =futureTask.get();45 System.out.println("总和为：" +sum);46 } catch(InterruptedException e) {47 e.printStackTrace();48 } catch(ExecutionException e) {49 e.printStackTrace();50 }51
52 }53 }

方式四：使用线程池

1、提供指定线程数量的线程池

2、执行指定的线程的操作，需要提供实现Runnable接口(或Callable接口)对象

代码如下：

1 /**
2 * 创建线程的方式四：使用线程池3 *4 * 好处：5 * 1、提高响应速度(减少了创建新线程的时间)6 * 2、降低资源消耗(重复利用线程池中线程，不需要每次都创建)7 * 3、便于线程管理8 * 1)corePoolSize:核心池的大小9 * 2)maximumPoolSize:最大线程数10 * 3)keepAliveTime:线程没有任务时最多保持多长时间后会终止11 * 。。。12 *13 * 面试题：创建多线程有几种方式？四种14 */
15
16 class NumberThread implementsRunnable {17
18
19 @Override20 public voidrun() {21 for (int i = 0; i <= 100; i++) {22 if (i % 2 == 0) {23 System.out.println(Thread.currentThread().getName() + "：" +i);24
25 }26 }27 }28 }29
30 public classThreadPool {31 public static voidmain(String[] args) {32 //1、提供指定线程数量的线程池
33 ExecutorService service = Executors.newFixedThreadPool(10);34
35 //2、执行指定的线程的操作，需要提供实现Runnable接口对象36 //适合适用于Runnable
37 service.execute(newNumberThread());38 //适合适用于Callable39 //service.submit(Callable callable)
40
41 service.shutdown();42 }43 }

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异常

boolean isAlive():返回boolean，判断线程是否还活着

stop():强制线程生命期结束，不推荐使用

示例代码

1 packagecom.hd.thread1;2
3 /**
4 * 测试Thread类的常用方法5 * 1、start()：启动当前线程；调用当前线程的run()6 * 2、run()：通常需要重写Thread类的此方法，将创建的线程要执行的操作声明在此方法中7 * 3、currentThread()：静态方法，返回执行当前代码的线程8 * 4、getName()：获取当前线程的名字9 * 5、setName()：设置当前线程的名字10 * 6、yield()：释放当前CPU的执行权11 * 7、join()：在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完成以后，线程a才结束阻塞状态12 * 8、stop()：已过时。当执行此方法时，强制结束当前线程13 * 9、sleep(long millitime)：让当前线程"睡眠"指定的millitime毫秒数。在指定的millitime毫秒时间内，当前线程时阻塞状态14 * 10、isAlive()：判断当前线程是否存活15 * 
16 * 线程的优先级17 * 1、线程的优先级等级18 * MAX_PRIORITY:1019 * MIN _PRIORITY:120 * NORM_PRIORITY:5 --> 默认优先级21 * 2、如何获取和设置当前线程的优先级22 * getPriority()：获取线程的优先级23 * setPriority(int p)：设置线程的优先级24 * 
25 * 说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，26 * 高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行27 */
28
29 class HelloThread extendsThread {30 @Override31 public voidrun() {32 for (int i = 0; i < 100; i++) {33 if (i % 2 == 0) {34 try{35 sleep(10);36 } catch(InterruptedException e) {37 e.printStackTrace();38 }39 System.out.println(Thread.currentThread().getName() + " : " +
40 Thread.currentThread().getPriority() + " : " +i);41 }42
43 if (i % 20 == 0) {44 //释放当前CPU的执行权
45 this.yield();46 }47 }48 }49 }50
51 public classThreadMethodTest {52 public static void main(String[] args) throwsInterruptedException {53 HelloThread t = newHelloThread();54 //设置线程名称
55 t.setName("线程1");56 t.setPriority(Thread.MAX_PRIORITY);57 t.start();58
59 Thread.currentThread().setName("主线程");60 Thread.currentThread().setPriority(Thread.MIN_PRIORITY);61
62 for (int i = 0; i < 100; i++) {63 if (i % 2 != 0) {64 System.out.println(Thread.currentThread().getName() + " : " +
65 Thread.currentThread().getPriority() + " : " +i);66 }67
68 //if (i == 19) {69 //t.join();70 //}
71 }72
73 System.out.println("线程1的状态：" +t.isAlive());74 }75 }

线程调度规则

优先级抢占调度

操作系统总是让具有最高优先级的就绪任务有限运行：当有任务的优先级高于当前任务的优先级并且处于就绪态后，就一定会发生系统调度。通过优先级抢占机制，最大限度地满足了系统的实时性。

时间片轮询调度

当操作系统中存在优先级相同的线程时(优先级相同就不会发生抢占)，操作系统会按照线程设置的时间片大小轮流调度线程，时间片起到约束线程单次执行时长的作用，其单位是1个系统节拍(OS Tick)。时间片轮询调度机制，保证优先级相同的线程轮流占用处理器。

Java的调度方法

1、同优先级线程组成先进先出队列(先到先服务)，使用时间片策略 

2、对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级等级

MAX_PRIORITY:10 
MIN _PRIORITY:1
NORM_PRIORITY:5

涉及的方法

1、getPriority() :返回线程优先值

2、setPriority(int newPriority) :改变线程的优先级

说明

线程创建时继承父线程的优先级 

低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用