廖雪峰Java11多线程编程-1线程的概念-2创建新线程
Java语言内置多线程支持：
- 一个Java程序实际上是一个JVM进程
- JVM用一个主线程来执行main()方法
- 在main()方法中又可以启动多个线程
1.创建新线程
要启动一个线程，需创建一个线程对象。创建线程对象的方法有3种。
1.1 方法一：使用Thread创建线程
创建MyThread类：
- 从Thread派生
- 覆写run()方法
- 创建MyThread()实例
- 对这个实例调用start()启动线程
class MyThread extends Thread{
public void run(){
System.out.println("子线程");
}
}
public class Main {
public static void main(String[] args){
Thread t = new MyThread();
t.start();
}
}
疯狂Java示例
package com.thread;
public class FirstThread extends Thread{
private int i;
public FirstThread(){}
public FirstThread(String name){
super(name);
}
public void run(){
for(;i<10;i++) {
System.out.println(getName()+i);
}
}
public static void main(String[] args) throws InterruptedException{
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+i);
if(i==5){
new FirstThread().start();
Thread.sleep(500);
new FirstThread("通过集成Thread创建新线程").start();
}
Thread.sleep(500);
}
}
}
1.2 方法二：使用Runnable接口创建新线程
如果一个类已经从某个类派生，无法从Thread继承：
- 实现Runnable接口
- 覆写run()接口
- 在main()方法中创建Runnable实例
- 创建Thread实例并传入Runnable
- 调用start()启动线程
class MyThread implements Runnable{
public void run(){
System.out.println("子线程");
}
}
public class Main {
public static void main(String[] args){
Runnable mt = new MyThread();
Thread t = new Thread(mt);
t.start();
}
}
疯狂Java示例
package com.thread;
public class SecondThread implements Runnable{
private int i;
public void run(){
for(;i<10;i++){
System.out.println(Thread.currentThread().getName()+"的循环变量"+i);
}
}
public static void main(String[] args) throws InterruptedException{
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"的循环变量"+i);
if(i==5){
SecondThread st = new SecondThread();
new Thread(st,"新线程1").start();
Thread.sleep(500);
new Thread(st,"新线程2").start();
Thread.sleep(500);
}
Thread.sleep(500);
}
}
}
1.3 方法三：使用Futrue和Callable创建子线程
实现Callable接口，覆写call()方法。再用Future进行转换
class WithResult implements Callable<Integer>{
@Override
public Integer call() throws Exception {
return 5;
}
}
public class ForZhang {
public static void main(String[] args) throws Exception{
Callable<Integer> th = new WithResult();
FutureTask task = new FutureTask<>(th);
new Thread(task,"有返回值的线程").start();
}
}
示例
package com.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThirdThread{
public static void main(String[] args) throws InterruptedException{
ThirdThread th = new ThirdThread();
FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
int i=0;
for(;i<10;i++){
System.out.println(Thread.currentThread().getName()+"的循环变量的值"+i);
}
return i;
});
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"循环变量的值"+i);
if(i==5){
new Thread(task,"有返回值的线程").start();
}
Thread.sleep(500);
}
try{
System.out.println("线程task的返回值："+task.get());
}catch (ExecutionException e){
e.printStackTrace();
}
}
}
同
class WithResult implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int i=0;
for(;i<10;i++){
System.out.println(Thread.currentThread().getName()+"的循环变量的值"+i);
}
return i;
}
}
public class ThirdThread {
public static void main(String[] args) throws Exception{
Callable<Integer> th = new WithResult();
FutureTask task = new FutureTask<>(th);
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"循环变量的值"+i);
if(i==5){
new Thread(task,"有返回值的线程").start();
}
Thread.sleep(500);
}
try{
System.out.println("线程task的返回值："+task.get());
}catch (ExecutionException e){
e.printStackTrace();
}
}
}
2.启动线程需要注意的地方
2.1 直接调用run()方法
直接调用run()方法是无效的，相当调用普通的Java的方法，当前线程没有任何的改变，也不会启动新的线程。
class MyThread extends Thread{
public void run(){
System.out.println("当前线程"+Thread.currentThread().getName()+"\tHello");
}
}
public class Main {
public static void main(String[] args){
Thread t = new MyThread();
t.run();//直接调用run()方法
Thread t2 = new MyThread();
t2.start();
System.out.println("主线程"+Thread.currentThread().getName());
}
}
start源码
class Thread implements Runnable {
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0(); //调用JVM虚拟机内部的start0()方法
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {}
}
}
private native void start0(); //native表示JVM虚拟机内部的C代码实现的，不是由Java代码实现的
2.2 新线程和主线程是同时执行
默认情况下，新线程和主线程是同时执行的，由操作系统调度，程序本身无法确认线程的的调度顺序
class HelloThread extends Thread{
String name;
public HelloThread(String name){
this.name = name;
}
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("Hello, " + name + "!");
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args){
Thread t1 = new HelloThread("Bob");
t1.start();
Thread t2 = new HelloThread("Alice");
t2.start();
for(int i=0;i<3;i++){
System.out.println("Main!");
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
3 线程的优先级
- 可以对线程设定优先级 Thread.setPriority(int n)//1-10，默认值5
- getPriority()获取线程的优先级
- 每个线程默认的优先级都与创建它的父线程的优先级相同，默认情况下，main线程具有普通优先级，其子线程也具有普通优先级。
- 优先级高的线程被操作系统调度的优先级高
- 不能通过设置优先级来确保功能的执行顺序
public class PriorityTest extends Thread{
public PriorityTest(String name){
super(name);
}
public void run(){
for(int i=0;i<50;i++){
System.out.println(getName()+"，其优先级是："+getPriority()+"的循环变量的值为："+i);
}
}
public static void main(String[] args){
Thread.currentThread().setPriority(6);
for(int i=0;i<30;i++){
if(i==10){
PriorityTest low = new PriorityTest("低级");
low.start();
System.out.println("创建之初的优先级："+low.getPriority());
low.setPriority(Thread.MIN_PRIORITY);
}
if(i==20){
PriorityTest high = new PriorityTest("高级");
high.start();
System.out.println("创建之初的优先级："+high.getPriority());
high.setPriority(Thread.MAX_PRIORITY);
}
}
}
}
高优先级的线程将会获得更多的执行机会，因此尽管高优先级的执行晚，却早结束。
虽然Java提供了10个优先级，但不同操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级对应，因此尽量使用MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY
4总结：
- Java用Thread对象表示一个线程，通过调用start()启动一个线程
- 一个线程对象只能调用一次start()
- 线程的执行代码是run()方法
- 线程调度由操作系统决定，程序本身无法决定
- Thread.sleep()可以把当前线程暂停一段时间
