Java多线程--初步介绍

最新推荐文章于 2024-08-05 16:47:18 发布

VoidCool

最新推荐文章于 2024-08-05 16:47:18 发布

阅读量225

点赞数

分类专栏： Java 文章标签： Java 多线程线程

本文链接：https://blog.csdn.net/woleen/article/details/48521875

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Java多线程--初步介绍：

一、线程和进程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程可以启动多个线程。进程是系统进行资源分配和调度的一个独立单位。

线程是指进程中的一个执行流程，一个进程中可以有多个线程。线程是CPU调度和分派的基本单位。是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

二、Java中线程的实现

在Java中实现多线程有两种方式实现：

(1) 继承Thread类，重写run()方法，然后直接new这个对象的实例，创建一个线程实例。然后调用start()方法启动线程。

(2) 实现Runnable接口，重写run()方法，然后new Thread(runnable)的方式创建一个线程，然后调用start()方法启动线程。

Thread构造方法：

Thread()
分配新的 Thread 对象。
Thread(Runnable target)
分配新的 Thread 对象。
Thread(Runnable target,String name)
分配新的 Thread 对象。
Thread(String name)
分配新的 Thread 对象。
Thread(ThreadGroup group,Runnable target)
分配新的 Thread 对象。
Thread(ThreadGroup group,Runnable target,String name)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。
Thread(ThreadGroup group,Runnable target,String name, long stackSize)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈大小。
Thread(ThreadGroup group,String name)
分配新的 Thread 对象。

1、通过继承Thread类实现多线程。

例子：

class myThread extends Thread{
private String name;
public myThread(String name){
this.name = name;
}
public void run(){
for(int i = 0; i <= 10;i++){
System.out.println(this.name + "running:" + i);
}
}
}
public class ThreadDemo{
public static void main(String[]args){
myThread tm1 = new myThread("Thread-A");
tm1.start();
myThread tm2 = new myThread("Thread-B");
tm2.start();
}
}

(1) 自定义类myThread继承Thread类，然后定义构造方法，覆写run()方法。

(2) 然后new 一个对象实例tm1(myThread tm1 = new myThread("Thread-A");)。

(3) 最后用对象实例tm1.start()启动线程。

注意：一个类通过继承Thread来实现多线程，那么只能调用一次start()方法，如果调用多次将会抛出“IllegalThreadStateException”异常。

2、通过实现Runnable接口实现多线程。

例子：

class MyThread implements Runnable{
private String name;
public MyThread(String name){
this.name = name;
}
public void run(){
for(int i = 0;i < 10;i++){
System.out.println(this.name + "running:" + i);
}
}
}
public class RunnableDemo{
public static void main(String[]args){
MyThread mt = new MyThread("Runnable-A");
Thread t = new Thread(mt,"A_B");
t.start();
}
}

(1) 自定义类myThread类实现接口Runnable，定义构造方法，覆写run()方法。

(2) 通过new实例化myThread对象（实例化Runnable子类对象）(MyThread mt = new MyThread("Runnable-A"))。

(3) 通过new实例化Thread类对象(Thread t = new Thread(mt,"A_B");)。

(4) 通过Thread类对象启动线程。

注：Runable接口实现多线程，必须依靠Thread类才能启动多线程。

3、两种实现多线程方式的联系和区别

通过Thread类和Runnable接口都可以实现多进程。

Thread类的定义:public class Thread extends Object implements Runnable,Thread 类也是Runnable的子类。但在Thread类中并没有完全的实现Runnable接口中的run（）方法。在Thread类中run()方法是调用Runnable接口中的run()方法，也就是说此方法是由Runnable的子类完成的。所以如果想通过Thread类实现多线程，则必须覆写run()方法。

通过继承Thread实现多线程，不适用于多线程共享资源，而Runnable可以很方便的共享资源。

实现Runnable接口相对继承Thread的优势：

(1) 适合多个相同程序代码的线程处理同一资源

(2) 可以避免由于继承带来的局限性。

(3) 增1强程序的健壮性，代码能够被多个线程共享，代码与数据时独立的。

在开发中建议使用Runnable接口实现多线程。

三、线程的状态

在Java中任何线程都有五种状态。即创建，就绪，运行，阻塞，终止。

创建：在程序中用构造方法创建了一个线程对象后，新的线程对象处于新建状态，此时，它已经有了相应的内存空间和其他资源，但处于不可运行状态。新建一个线程对象可采用Thread类的构造方法来实现，例如：Thread myThread = new Thread();

就绪：新建线程对象后，调用该线程的start()方法可以启动线程。线程启动后，就进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务。

运行：当就绪状态的线程被调用并且获得了CPU资源，线程进入运行状态。此时，调用线程的run()方法进行操作。

阻塞：一个正在运行的线程在某些特殊的情况下，如被人为挂起或需要执行耗时的输入输出，将让出CPU并中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait()等方法，线程将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

终止（死亡）：线程调用stop()方法或者run()方法执行结束后，即处于死亡状态。

四、线程的状态的控制

虽然Thread类现实了Runnable接口，但是操作线程的主要方法是在Thread类中定义的。

1、sleep()方法

public static void sleep(long mills) throws InterruptedException

可以发现sleep()方法是一个静态方法，如果想让当前正在执行的线程暂停一段时间，并进入阻塞状态，可以直接使用Thread.sleep()方法。参数单位为毫秒。

注意：

(1)sleep()方法是静态方法，最好不要用Thread的实例对象调用它，它的作用为当前正在运行的线程，而不是调用它的线程，只对正在运行状态的线程有效。

(2)使用sleep()之后，线程进入阻塞状态，只有当时间结束，才会重新进入就绪状态，而就绪状态到运行状态，是由系统控制的。

2、yield()方法线程让步

public static void yield() 将目前正在执行的线程暂停，允许其他线程执行

在线程操作中，可以使用yield()方法将一个线程的操作暂时让给其他线程执行。

yield()方法也是Thread类的一个静态方法，它会让当前正在运行的线程暂停一下，重新进入就绪状态。让线程进入就绪的线程池，让系统的线程调度器重新调度一次。

使用方法：Thread.yield();

sleep()和yield()方法的区别：

(1) sleep()方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield()方法调用后，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。

(2) sleep()方法声明抛出了InterruptedException，所以调用sleep()方法的时候要捕获该异常，或者显示声明抛出该异常。而yield()方法则没有声明抛出任务异常。

(3) sleep()方法比yield()方法有更好的可移植性，通常不要依靠yield()方法来控制并发线程的执行

3、join()方法线程强制执行

public final void join() throws InterruptedException

public final synchronized void join(long millis) throws InterruptedException

在线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。（需要等到join进来的线程执行完才会继续执行当前线程）

class myThread implements Runnable{
public void run(){
for(int i = 0;i < 50;i++){
System.out.println(Thread.currentThread().getName() + " running:" + i);
}
}
}
public class ThreadJoinDemo{
public static void main(String[]args){
myThread mt = new myThread();
Thread t = new Thread(mt,"Thread-A");
t.start();
for(int i=0;i<50;i++){
if(i > 10){
try{
t.join();
}catch(Exception e){}
}
System.out.println("Main :"+i);
}
}
}

五、线程的优先级

每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行计划，而优先级低的线程则获得较少的执行机会。线程的优先级不会保障线程的执行次序，只不过，优先级高的线程获得CPU的概率比较大，优先级低的获得的概率小。

在java中可以使用setPriority()方法设置一个线程的优先级。getPriority()方法可以返回一个线程的优先级。

public static final int MIN_PRIORITY 最低优先级表示常量1

public static final int NORM_PRIORITY 中等优先级，是线程默认的优先级表示常量5

public static final int MAX_PRIORITY 最高优先级表示常量10

java例子：

class myThread implements Runnable{
public void run(){
for(int i = 0;i < 50;i++){
System.out.println(Thread.currentThread().getName() + " running:" + i);
}
}
}
public class ThreadPriorityDemo{
public static void main(String[]args){
myThread mt1 = new myThread();
myThread mt2 = new myThread();
myThread mt3 = new myThread();
Thread t1 = new Thread(mt1,"Thread-A");
Thread t2 = new Thread(mt2,"Thread-B");
Thread t3 = new Thread(mt3,"Thread-C");
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t3.setPriority(Thread.NORM_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}