线程
线程,又是轻量级进程。程序中的一个顺序控制流程,同时也是CPU的基本调度单位。进程由多个线程组成,彼此间完成不同的工作,交替运行,成为多线程
创建的线程方式
~第一种,继承Thread
而Thread 类本质上是实现了 Runnable 接口的一个实例,代表一个线程的实例,重写run方法,完成任务
public class ThreadTest {
public static void main(String[] args) {
MyThread mt = new MyThread();
MyThread2 mt2 = new MyThread2();
//开启线程
mt.start();
mt2.start();
System.out.println("程序结束");
}
}
//线程1继承Thread
class MyThread extends Thread{
public void run() {
for(int i=0 ;i<50;i++) {
System.out.println("myThread:"+i);
}
}
}
//线程2继承Thread
class MyThread2 extends Thread{
public void run() {
for(int i=0;i<50;i++) {
System.out.println("myThread2:"+i);
}
}
}
~第二种方式,实现Runnable接口
注:如果自己的类已经 extends 另一个类,就无法直接 extends Thread,此时,可以实现一个 Runnable 接口
package ThreadMost;
public class RunnableTest {
public static void main(String[] args) {
//创建实现类对象
MyRunnable mr = new MyRunnable();
MyRunnable2 mr2 = new MyRunnable2();
//将任务交给线程
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr2);
//开启线程
t1.start();
t2.start();
System.out.println("程序结束");
}
}
//线程1实现Runnable接口
class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i =1;i<50;i++) {
System.out.println("MyRunnable:"+i);
}
}
}
//线程2实现Runnable接口
class MyRunnable2 implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i =1;i<50;i++) {
System.out.println("MyRunnable2:"+i);
}
}
}
~第三种方式,实现Callable接口
具有线程返回值,可以声明异常
注:有返回值的任务必须实现 Callable 接口,类似的,无返回值的任务必须 Runnable 接口
public class CallableTest {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建一个线程池
ExecutorService es = Executors.newFixedThreadPool(3);
Callable<Integer> cb1 = new CallTest();
Callable<Integer> cb2 = new CallTest();
// 执行任务并获取 Future 对象
Future<Integer> s1 = es.submit(cb1);
Future<Integer> s2 = es.submit(cb2);
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
Integer i1 = s1.get();
Integer i2 = s1.get();
System.out.println(i1+"\t"+i2);
}
}
class CallTest implements Callable<Integer>{
//实现接口重写方法
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
int sum = 0;
for(int i=0;i<100;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
sum +=i;
}
return sum;
}
}
- Future接口
异步接收ExecutorService.submit()所返回的状态结果,当中包含了call()的返回值。
以.get()阻塞方式等待Future中的异步处理结果
~第四种方式,基于线程池的方式
线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建,不需要的时候销
毁,是非常浪费资源的。那么我们就可以使用缓存的策略,也就是使用线程池。
public class RunnableTest {
public static void main(String[] args) {
// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while(true) {
threadPool.execute(new Runnable() { // 提交多个线程任务,并执行
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running ..");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
希望可以帮助到您