Java中的多线程

一、提要
java中的多线程算是java中的一个 很大的难点 ,虽然 看了 很多书 ,相信对于 很多 接触 java不够 深的人来说 ,多线程永远都是心中的痛!
今天我们 就 通过大量的 例子 来 彻底把它征服 .


二、Runable接口
实现 Runable接口 是 实现多线程 的 一种方法。看例子 
package thread;
public class LiftOff implements Runnable {
protected int countDown = 10; // Default
private static int taskCount = 0;
private final int id = taskCount++;
public LiftOff() {}
public LiftOff(int countDown) {
this.countDown = countDown;
}
public String status() {
return "#" + id + "(" +
(countDown > 0 ? countDown : "Liftoff!") + "), ";
}
public void run() {
while(countDown-- > 0) {
System.out.print(status());
Thread.yield();
}
}
} 




这个类的实现了 一个线程 :implements了Runable接口 ,实现了 run方法。
通常情况下,run方法中都会有意个循环 ,直到任务结束的时候才会跳出来。
线程的主要任务是循环十次,每次打印出 终端 状态。Thread.yield()的作用是如果线程队列中有线程等待,则阻塞自己,
将资源 交给 下一个等待的线程。


在main函数中 调用如下:
package thread;
public class Main {
public static void main(String[] arges)
{
LiftOff tmp=new LiftOff();
tmp.run();
System.out.println("Waiting for LiftOff");
}
}


将类型初始化实例时候 ,直接 调用run方法,线程就会开始运行。
运行结果:
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), Waiting for LiftOff
这里实际上并没有线程的概念,只是用到了一些简单的函数调用。
真正的线程需要将Runable装到一个Thread中去。


三、Thread实例
传统的使用Runable对象的方法就是把它作为一个参数传给Thread的构造函数作为参数,然后调用Thread的start()方法来启动线程。
start()方法对Runale进行 了 一些 必要的初始化,然后调用Runable的run方法。
将原main函数改写如下:
package thread;
public class Main {
public static void main(String[] arges)
{
Thread t = new Thread(new LiftOff());
t.start();
System.out.println("Waiting for LiftOff");


}
}


运行结果:
Waiting for LiftOff
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), 


运行的结果和之前的例子类似,但“Waiting for LiftOff“出现的位置不同了。
原理:在程序的第五行声明了一个线程,并初始化,一个LiftOff对象作为参数传进去。
第六行通过线程调用启动了t线程,但main线程还可以继续干自己的事,cpu给的时间片还没用完,于是“Waiting for LiftOff”就先被打印出来了,之后时间片被用完了,资源交给t线程,运行的内容被打印出来了。
下面是在main中启动多个线程:
package thread;
public class Main {


public static void main(String[] arges)
{
for(int i = 0; i < 5; i++)
new Thread(new LiftOff()).start();
System.out.println("Waiting for LiftOff");
}
}


修改一下LiftOff类:
package thread;
public class LiftOff implements Runnable {
private static int taskCount = 0;
private final int id = taskCount++;
public LiftOff() {}
public void run() {
System.out.println("startThreadId: " + id);
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
}
System.out.println("endTHreadId: " + id);
}
} 


运行结果:
startThreadId: 0
startThreadId: 1
startThreadId: 2
startThreadId: 3
Waiting for LiftOff
startThreadId: 4
endTHreadId: 0
endTHreadId: 1
endTHreadId: 2
endTHreadId: 3
endTHreadId: 4




运行的结果反映了多线程运行的时候线程的调度。调度的规则主要由线程管理器来决定,在多核心的计算机中,线程管理器会把线程交由不同的cpu来完成。
由于线程的调度机制并不是确定的,不同版本的jdk所得到的结果是不同的。
对于打印结果的理解:运行之后哦main线程尝试创建5个线程,但在创建#3进程的时候时间片用完了,main的Thread进入等待队列,接着时间片论转到最先进入线程队列的#0进程->#0时间片用完(线程还没销毁)->时间片轮转到#1->#1时间片用完....(看不懂的要回头学一下操作系统中进程管理的知识)。


四、使用Executors
线程池由 Executor 框架提供。 Executor 框架将处理请求任务的提交和它的执行解耦。可以制定执行策略。在线程池中执行线程可以重用已经存在的线程,而不是创建新的线程,可以在处理多请求时抵消线程创建、消亡产生的开销。
ExecutorService 的几个重要方法:
1、shutdown方法:这个方法会平滑地关闭ExecutorService,当我们调用这个方法时,ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类:一类是已经在执行的,另一类是还没有开始执行的),当所有已经提交的任务执行完毕后将会关闭ExecutorService。
2、awaitTermination方法:这个方法有两个参数,一个是timeout即超时时间,另一个是unit即时间单位。这个方法会使线程等待timeout时长,当超过timeout时间后,会监测ExecutorService是否已经关闭,若关闭则返回true,否则返回false。一般情况下会和shutdown方法组合使用
直接看代码:
package thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {


public static void main(String[] arges)
{
//ExecutorService exec = Executors.newSingleThreadExecutor();
ExecutorService exec = Executors.newFixedThreadPool(3);
for(int i = 0; i <5; i++)
{
try{
exec.execute(new LiftOff());
//Thread.sleep(1000);
}catch(Exception e)
{
e.printStackTrace();
}
}
exec.shutdown();
System.out.println("Waiting for LiftOff");
}
}


运行结果:
startThreadId: 0
startThreadId: 1
Waiting for LiftOff
startThreadId: 2
endThreadId: 0       
startThreadId: 3
endThreadId: 1       
startThreadId: 4
endThreadId: 2       
endThreadId: 3       
endThreadId: 4       




newCachedThreadPool()创建一个可根据需要创建新线程的线程池,newSingleThreadExecutor()约等于newFixedThreadPool(1)


SingleThreadExecutor运行结果:
Waiting for LiftOff
startThreadId: 0
endThreadId: 0       
startThreadId: 1
endThreadId: 1       
startThreadId: 2
endThreadId: 2       
startThreadId: 3
endThreadId: 3       
startThreadId: 4
endThreadId: 4       
    


CachedThreadPool运行结果:
startThreadId: 0
startThreadId: 1
startThreadId: 2
startThreadId: 3
Waiting for LiftOff
startThreadId: 4
endThreadId: 0       
endThreadId: 1       
endThreadId: 2       
endThreadId: 3       
endThreadId: 4       
     


Executors还是有点难理解,需要很多的实战才能有更好的体会,这里点到为止。




五、Callable 和 Future接口   
 Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。   
 Callable和Runnable有几点不同:   
 (1)Callable规定的方法是call(),而Runnable规定的方法是run().   
 (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。   
 (3)call()方法可抛出异常,而run()方法是不能抛出异常的。   
(4)运行Callable任务可拿到一个Future对象,   
 Future 表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。   
 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。   

代码示例:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableTest {
    /** *//**   
     * 自定义一个任务类,实现Callable接口   
     */    
    public static class MyCallableClass implements Callable{     
        // 标志位     
        private int flag = 0;     
        public MyCallableClass(int flag){     
            this.flag = flag;     
        }     
        public String call() throws Exception{     
            if (this.flag == 0){     
                // 如果flag的值为0,则立即返回     
                return "flag = 0";     
            }      
            if (this.flag == 1){     
                // 如果flag的值为1,做一个无限循环     
                try {     
                    while (true) {     
                        System.out.println("looping.");     
                        Thread.sleep(2000);     
                    }     
                } catch (InterruptedException e) {  
                //如果线程被终止,打印提示
                    System.out.println("Interrupted");     
                }     
                return "false";     
            } else {     
                // falg不为0或者1,则抛出异常     
                throw new Exception("Bad flag value!");     
            }     
        }     
    }     
         
    public static void main(String[] args) {     
        // 定义3个Callable类型的任务     
        MyCallableClass task1 = new MyCallableClass(0);     
        MyCallableClass task2 = new MyCallableClass(1);     
        MyCallableClass task3 = new MyCallableClass(2);     
             
        // 创建一个执行任务的服务     
        ExecutorService es = Executors.newFixedThreadPool(3);     
        try {     
            // 提交并执行任务,任务启动时返回了一个 Future对象,     
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作     
            Future future1 = es.submit(task1);     
            // 获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行     
            System.out.println("task1: " + future1.get());     
                 
            Future future2 = es.submit(task2);     
            // 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环     
            Thread.sleep(6000);     
            System.out.println("task2 cancel: " + future2.cancel(true));     
                 
            // 获取第三个任务的输出,因为执行第三个任务会引起异常     
            // 所以下面的语句将引起异常的抛出     
            Future future3 = es.submit(task3);     
            System.out.println("task3: " + future3.get());     
        } catch (Exception e){     
            System.out.println(e.toString());     
        }     
        // 停止任务执行服务     
        es.shutdownNow();     
    }     


}


运行结果:
task1: flag = 0
looping.
looping.
looping.
task2 cancel: true
Interrupted
java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!

### 回答1: Java 多线程可以通过创建 Thread 类的实例来实现。具体步骤如下: 1. 创建一个实现 Runnable 接口的类,该类实现 run() 方法。 ```java public class MyRunnable implements Runnable { public void run() { // 执行线程的操作 } } ``` 2. 创建一个 Thread 实例,并将实现了 Runnable 接口的类作为构造函数的参数。 ```java MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); ``` 3. 启动线程。 ```java thread.start(); ``` 此外,还可以通过继承 Thread 类来实现多线程。具体步骤如下: 1. 创建一个继承自 Thread 类的类,重写 run() 方法。 ```java public class MyThread extends Thread { public void run() { // 执行线程的操作 } } ``` 2. 创建 MyThread 的实例。 ```java MyThread myThread = new MyThread(); ``` 3. 启动线程。 ```java myThread.start(); ``` 在多线程的使用,需要注意线程安全的问题,比如共享变量的访问、同步操作等。可以使用 synchronized 关键字或者 Lock 接口来保证线程安全。 ### 回答2: 在Java多线程的使用是指程序同时运行多个线程,每个线程执行自己的任务Java多线程的使用可以带来以下几点好处: 1. 提高程序的效率:多线程可以对多个任务进行并发处理,提高程序的运行效率。例如,可以将网络请求和UI界面分别放在两个不同的线程,这样即使网络请求比较耗时,UI界面也能进行响应,不会出现界面假死的情况。 2. 充分利用系统资源:多线程可以充分利用系统的处理器资源,提高系统的利用率。在多核处理器上运行多个线程,可以让每个核心都得到充分利用,提高系统的整体性能。 3. 实现异步编程:多线程可以实现异步编程,即一个线程执行后续操作,不需要等待另一个线程的完成。这样可以提高程序的响应速度。例如,可以使用多线程来进行文件下载,下载过程可以同时进行其他操作。 4. 处理复杂的并发情况:在一些需要处理多个并发操作的场景多线程可以提供更好的解决方案。例如,在并发访问共享资源的情况下,使用线程锁可以保证对共享资源的安全访问,避免数据冲突和一致性问题。 Java使用多线程可以通过创建Thread类的实例或者实现Runnable接口来实现。通过继承Thread类来创建线程,需要重写run方法,在run方法定义线程要执行的任务。通过实现Runnable接口来创建线程,需要实现run方法,并将实现了Runnable接口的对象作为参数传递给Thread类的构造方法。 总之,Java多线程的使用使得程序可以同时执行多个任务,提高了程序的效率和用户体验,并且能够处理复杂的并发情况。但需要注意多线程的安全性和线程之间的协作,避免出现数据冲突和一致性问题。 ### 回答3: Java多线程的使用是指在一个程序同时执行多个任务或者同时处理多个请求。多线程可以提高程序的并发性和响应性,可以将耗时的操作和任务分配给不同的线程来执行,从而提高程序的运行效率。 在Java多线程的使用主要依靠Thread类或者实现Runnable接口来创建线程。可以通过继承Thread类创建一个线程类,并重写run方法,在run方法定义需要执行的任务;也可以实现Runnable接口,创建一个Runnable对象,然后将该对象作为参数传递给Thread类的构造方法,创建一个线程对象。 使用多线程的好处是可以充分利用处理器的多核特性,同时进行多个任务,提高程序的运行效率。多线程还可以提高程序的响应性,当程序有耗时的操作时,可以将其放在一个独立的线程执行,防止主线程被阻塞,提高用户体验。 然而,多线程的使用也存在一些问题。首先是线程安全问题,多个线程同时访问共享资源可能导致数据不一致或者数据损坏。为解决这个问题,可以使用同步机制,如synchronized关键字或Lock接口,保证在同一时间只有一个线程能够访问共享资源。其次,多线程的创建和销毁会消耗系统资源,如果线程数量过多,可能会影响系统性能。因此,在使用多线程时应该合理控制线程的数量。另外,线程之间的协调和通信也是一个值得关注的问题,可以使用wait、notify、join等方法来实现线程间的协作。 总之,Java多线程的使用可以提高程序的并发性和响应性,但需要注意线程安全、资源消耗以及线程协调和通信等问题。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值