Java多线程---线程的创建和使用

Java多线程---线程的创建和使用

主要内容

程序、进程、线程的概念

Java中多线程的创建和使用

1、继承Thread类与Thread类的主要方法

2、实现Runable接口

3、线程的调度与设置优先级

一、程序、进程、线程的概念

1、程序(program)：可以理解为一段静态的代码，静态对象。是为了完成特定任务、用某种语言编写的一组指令的集合。

2、进程(process):它是内存中的一段独立的空间，可以负责当前应用程序的运行。当前这个进程负责调度当前程序中的所有运行细节。

进程是一个动态过程，有它自己的产生、存在和消亡的过程。

3、线程(thread)：它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。

区别：进程是负责整个程序的运行，而线程是程序中具体的某个独立功能的运行。一个进程中至少应该有一个线程。

4、多线程：

在一个进程中，同时开启多个线程，让多个线程同时去完成某些任务（功能）。

(比如后台服务系统，就可以用多个线程同时响应多个客户的请求)

多线程的目的：提高程序的运行效率。

多线程运行原理：

cpu在线程中做时间片的切换。其实真正电脑中的程序的运行不是同时在运行的。

CPU负责程序的运行，而CPU在运行程序的过程中某个时刻点上，它其实只能运行一个程序。而不是多个程序。

而CPU它可以在多个程序之间进行高速的切换。而切换频率和速度太快，导致人的肉眼看不到。

每个程序就是进程， 而每个进程中会有多个线程，而CPU是在这些线程之间进行切换。

了解了CPU对一个任务的执行过程，我们就必须知道，多线程可以提高程序的运行效率，但不能无限制的开线程。
二、Java中多线程的创建和使用

1、继承Thread类

（1）实例：

package com.TestThread;
/*
* 创建一个子线程，完成1-100之间自然数的输出，同样，主线程也执行这个操作
* 创建多线程的第一种方式：继承java.lang.Thread类
*/
//1、创建一个继承于Thread的子类
class SubThread extends Thread{
//2、重写Thread类的run()方法,方法内实现此子线程要完成的功能
public void run(){
for(int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestThread {
public static void main(String[] args) {
//3、创建一个子类的对象
SubThread st1=new SubThread();
SubThread st2=new SubThread();
//4、调用线程的start()方法：启动此线程，调用相应的run()方法
//一个线程只能够执行一次start()方法
//不能通过Thread实现类对象的run()去启动一个线程
st1.start();
//st1.start()
//st1.run()
st2.start();
for(int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}

（2）Thread的常用方法

实例：

package com.TestThread;
/*
* Thread的常用方法
* 1.start():启动线程并执行相应的run()方法
* 2.run():子线程要执行的代码放入run()方法
* 3.currentThread()：静态的，调取当前的线程
* 4.getName():获取此线程的名字
* 5.setName():设置此线程 的名字
* 6.yield():调用此方法的线程释放当前CPU的执行权
* 7.join():在A线程中调用B线程的join()方法，表示当执行到此方法，A线程停止执行，直至B线程执行完成，A线程再接着join()之后的代码执行
* 8.isAlive():判断当前线程是否还存活
* 9.sleep(long L)：显式地让当前线程睡眠L毫秒
* 10.线程通信：wait()  notify()    notifyAll()
* 设置线程的优先级：时间片，抢占式
* getPriority():返回线程优先值
* setPriority(int new Priority):改变线程的优先级
*/
class SubThread1 extends Thread{
public void run(){
for(int i=1;i<=100;i++){
/*try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestThread1 {
public static void main(String[] args) {
SubThread1 st1=new SubThread1();
SubThread1 st2=new SubThread1();
st1.setName("子线程1");
st1.start();
st2.setName("子线程2");
st2.start();
Thread.currentThread().setName("=========主线程");
for(int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
/*if(i%10==0){
Thread.currentThread().yield();
}*/
if(i == 20){
try {
st1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
System.out.println(st1.isAlive());

}
}

（3）设置线程的优先级：时间片，抢占式

getPriority():返回线程优先值

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

MAX_PRIORITY(10) MIN_PRIORITY(1) NORM_PRIORITY(5)

（4）简单练习

模拟火车站售票窗口，开启三个窗口售票，总票数为100

（此程序存在线程安全问题，打印车票时可能出现重复车票以及错票，这只是一个简单的实现，没考虑线程安全问题）

package com.TestTh
ae4f
read;
//模拟火车站售票窗口，开启三个窗口售票，总票数为100
//方式一：继承Thread类
class Window extends Thread{
static int ticket=100;
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售出的票号为："+ticket--);
}else{
break;
}
}
}
}
public class TestWindow {

public static void main(String[] args) {
Window w1=new Window();
Window w2=new Window();
Window w3=new Window();

w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");

w1.start();
w2.start();
w3.start();
}
}

2、实现Runable接口

（1）实例：

package com.TestThread;
//方式二：实现Runnable接口
//1、创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable{
//2、实现接口的抽象方法
public void run() {
//子类执行的代码
for(int i=1;i<=100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}

}
}
public class TestRunnable {
public static void main(String[] args) {
//3、创建一个Runnable接口实现类的对象
PrintNum1 p=new PrintNum1();
//4、将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
Thread t1=new Thread(p);
//5、调用start()方法，启动线程并执行run()方法
t1.start();//启动线程，执行Thread对象生成时构造器形参的对象的run()方法

//再创建一个线程
Thread t2=new Thread(p);
t2.start();
}

}

（2）简单练习

模拟火车站售票窗口，开启三个窗口售票，总票数为100

（此程序存在线程安全问题，打印车票时可能出现重复车票以及错票，这只是一个简单的实现，没考虑线程安全问题）

package com.TestThread;
//使用实现Runnable接口方式售票

class Window1 implements Runnable{
int ticket=100;
public void run() {
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售出的票号为："+ticket--);
}else{
break;
}
}

}

}
public class TestWindow2 {

public static void main(String[] args) {
Window1 w=new Window1();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);

t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");

t1.start();
t2.start();
t3.start();
}
}

3、两种方式的对比

（1）联系：Thread类是实现Runnable接口的。

（2）实现Runnable接口的方式优于继承Thread类的方式

理由：a.避免了Java单继承的局限性

b.如果多个线程要操作同一份资源（或数据），更适合使用实现的方式。

作者： Aquamarine 
链接：https://www.imooc.com/article/22453
来源：慕课网