java多线程并发(一)-- 相关基础知识

  java多线程的知识是java程序员都应该掌握的技能,目前我接触的项目上用的不多,花点时间熟悉熟悉。

一、基础知识

  1、什么是进程?

  进程是具有一定独立功能的正在运行过程中的程序,是操作系统进行资源分配的最小单位,有程序、数据、进程控制块组成。进程内部有多个线程,这多个线程会共享资源。 

  2、什么是线程? 

  线程有时称为轻量级进程,是CPU调度的最小单位,依赖于进程存在。线程自己不拥有系统资源,与同属于同一进程下的线程共享系统资源。

  3、什么是并行?

  并行(parallel):同一时刻,有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看,二者都是一起执行的。

java多线程并发(一)-- 相关基础知识

  4、什么是并发?

  并发(concurrency):同一时刻只能有一条指令执行,但多个进程指令被快速的轮换执行,使得在宏观上具有多个进程同时执行的效果,但在微观上并不是同时执行的,只是把时间分成若干段,使多个进程快速交替的执行。

  java多线程并发(一)-- 相关基础知识

  5、多高并发优缺点?

  优点:充分利用系统资源、加快用户响应时间、程序模块化、异步化;

  缺点:线程共享资源,存在冲突,容易导致死锁。

二、java新启线程的三种方式

  1、继承Thread 类,重写run方法:

class UseThread extends Thread{
@Override
public void run() {
super.run();
System.out.println("[" + Thread.currentThread().getName() + "]已启动!");
}
} public class Test {
public static void main(String[] args){
Thread thread = new UseThread();
thread.setName("继承Thread的线程");
thread.start();
}
}

  2、实现Runable接口,实现run方法(或者内部类的形式)

class UseRunable implements Runnable{
@Override
public void run() {
System.out.println("[" + Thread.currentThread().getName() + "]已启动!");
}
} public class Test {
public static void main(String[] args){
Thread thread = new Thread(new UseRunable());
thread.setName("实现Runable接口的线程");
thread.start();
}
} 
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("哈哈哈哈");
}
});

  3、实现Callable接口,实现call方法

class UseCallable implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("[" + Thread.currentThread().getName() + "]已启动!");
return "12345";
}
} public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new UseCallable());
Thread thread = new Thread(futureTask);
thread.setName("实现Callable接口的线程");
thread.start();
System.out.println("call()方法返回的结果:" + futureTask.get());
}
}

  Runable与Callable的区别:

  1. Runable的执行方法是run(),而Callable的执行方法是call();
  2. Runable没有返回结果,Callable支持泛型方式的返回结果,通过和Futrue/FutureTask配合可以用来获取异步执行的结果(FutureTask实际上实现了Runable接口,本质上是将Callable转换为Runable);
    public class FutureTask<V> implements RunnableFuture<V> {
    ...
    };
    public interface RunnableFuture<V> extends Runnable, Future<V> {
      ...
    }
  3. Callable的call()可以向上抛出异常,而Runable的run()不能抛出异常,异常只能内部消化(因为Runable中的run()声明的抽象方法没有抛出异常);
    @FunctionalInterface
    public interface Runnable {
    public abstract void run();
    } @FunctionalInterface
    public interface Callable<V> {
    V call() throws Exception;
    }

    注: Callable执行返回结果需要通过Future.get()获取,该方法会阻塞主线程直到返回结果,而不调用则不会阻塞。

  正常见到的线程实现方式就是这三种,实际还有第四种!!!

  4、使用线程池

  

public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
int poolSize = 5;
ExecutorService executorService = Executors.newFixedThreadPool(poolSize);
List<Future<String>> futureList = new ArrayList<>();
for (int i=0;i<poolSize;i++){
int finalI = i;
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("[" + finalI + "号线程]已执行!");
return "" + finalI + "号线程";
}
});
futureList.add(future);
} for (Future future : futureList){
System.out.println("返回结果:" + future.get());
}
}
}

java多线程并发(一)-- 相关基础知识

  当然,上面线程池的实现方式本质上还是使用的的Callable,当然也可以使用Runable。

  一般是推荐使用Runable的方式,java不能多继承,接口的方式利于扩展。

  

上一篇:怎样从外网访问内网Zeus?


下一篇:Java编译器如何生成重载和覆盖方法代码