Java多线程并发编程（java多线程并发编程实例）

　　本篇文章为你整理了Java多线程并发编程（java多线程并发编程实例）的详细内容，包含有java多线程并发编程面试题 java多线程并发编程实例 java多线程并发编程书 java多线程并发编程pdf Java多线程并发编程，希望能帮助你了解 Java多线程并发编程。

　　在Java中，一个应用程序对应着一个JVM实例（也有地方称为JVM进程），如果程序没有主动创建线程，则只会创建一个主线程。但这不代表JVM中只有一个线程，JVM实例在创建的时候，同时会创建很多其他的线程（比如垃圾收集器线程）。

　　线程有三种创建方式：

　　继承Thread类（可以说是将任务和线程合并在一起）

　　实现Runnable接口（可以说是将任务和线程分开了）

　　实现Callable接口 (利用FutureTask执行任务)

　　对比：Runnable接口解决了Thread单继承的局限性。而Callable解决了Runnable无法抛异常给调用方的局限性。

class T extends Thread {

　　 @Override

　　 public void run() {

　　 println("我是继承Thread的任务");

　　class R implements Runnable { //解决了单继承问题

　　 @Override

　　 public void run() {

　　 println("我是实现Runnable的任务");

　　class C implements Callable String {

　　 @Override

　　 public String call() throws Exception { //可以抛异常

　　 println("我是实现Callable的任务");

　　 return "success"; //任务有返回值

　　调用线程的start()方法，这里要注意，只有Thread方法可以调用start()，因此需要为其他类型的线程创建方式实例分配Thread实例。

// 启动继承Thread类的任务

　　Thread MyThread = new MyThread();

　　MyThread.start();

　　class MyThread extends Thread {

　　 @Override

　　 public void run() {

　　 System.out.println("hello myThread" + Thread.currentThread().getName());

　　// 启动实现Runnable接口的任务

　　MyRunnable myRunnable = new MyRunnable();

　　Thread thread = new Thread(myRunnable); //要给实现Runnable的实例分配新的对象

　　thread.start();

　　class MyRunnable implements Runnable{

　　 @Override

　　 public void run(){

　　 System.out.println("hello myRunnable" + Thread.currentThread().getName());

　　// 启动实现了Callable接口的任务结合FutureTask 可以获取线程执行的结果

　　FutureTask String target = new FutureTask (new C()); //C是实现了Callable接口的类

　　new Thread(target).start();

　　log.info(target.get());

　　各线程类图

　　
加锁：把临界资源进行上锁，每次只允许一个线程进入访问完成后才解锁，允许其他进程进入

　　同步代码块

　　对代码块上锁

　　快捷键：CTRL+ALT+T

　　关于锁对象的选择

　　最好不要用任意唯一的锁对象，因为这会影响其他无关线程的执行。

　　规范上：建议使用临界资源作为锁对象

　　对于实例方法建议使用this作为锁对象

　　对于静态方法建议使用字节码(类名.class)作为锁对象

synchronized(同步锁对象) { //synchronized(this) 只锁自己的临界资源

　　 //操作系统资源的代码(出现安全问题的核心代码)

　　对方法上锁

　　在方法定义时加上synchronized关键字即可

　　同步方法底层有隐式锁对象

　　如果方法是实例方法：同步方法默认使用this作为锁对象

　　如果方法是静态方法：同步方法默认使用类名.class作为锁对象

修饰符 synchronized 返回值类型 方法名称(形参列表) {

　　 //操作系统资源的代码

　　Lock锁

//创建锁

　　private final Lock lock = new ReentranLock();

　　lock.lock(); //加锁

　　 try {

　　 //锁住的内容

　　 } finally {

　　 lock.unlock(); //解锁

　　典型应用：生产者-消费者模型

　　实现方法：使用一个共享变量实现线程通信

　　
方式一：使用ExecutorService的实现类ThreadPoolExecutor创建线程池对象

　　创建临时线程的条件：①核心线程全忙 ②任务队列满

　　拒绝任务的条件：临时线程和核心线程全忙

　　线程池处理Runnable任务的方法：

public class Communication {

　　 public static void main(String[] args) {

　　 //线程池创建

　　 ExecutorService pool = new ThreadPoolExecutor(3,5,2, TimeUnit.MINUTES, new ArrayBlockingQueue (5),new ThreadPoolExecutor.AbortPolicy());

　　 Runnable myRunnable = new myRunnable();

　　 //线程池产生Runnable线程对象

　　 pool.execute(myRunnable);

　　 //开始创建临时线程

　　 pool.execute(myRunnable);

　　 //抛出异常

　　 pool.execute(myRunnable);

　　 * 功能：用线程池实现Runnable对象

　　class myRunnable implements Runnable {

　　 @Override

　　 public void run() {

　　 for (int i = 0; i i++) {

　　 System.out.println(Thread.currentThread().getName() + "正在打印hello == " + i);

　　 try {

　　 System.out.println(Thread.currentThread().getName() + "开始睡眠");

　　 Thread.sleep(1000000);

　　 } catch (Exception e) {

　　 e.printStackTrace();

　　线程池处理Callable任务的方法

public class Communication {

　　 public static void main(String[] args) throws ExecutionException, InterruptedException {

　　 //线程池创建（不变）

　　 ExecutorService pool = new ThreadPoolExecutor(3,5,2,

　　 TimeUnit.MINUTES, new ArrayBlockingQueue (5),new ThreadPoolExecutor.AbortPolicy());

　　 //调用线程池的submit方法处理myCallable对象，并用Future Task的父类Future继承

　　 Future String f1 = pool.submit(new myCallable(100));

　　 Future String f2 = pool.submit(new myCallable(200));

　　 Future String f3 = pool.submit(new myCallable(300));

　　 Future String f4 = pool.submit(new myCallable(400));

　　 Future String f5 = pool.submit(new myCallable(500));

　　 //调用get方法返回内容

　　 System.out.println(f1.get());

　　 System.out.println(f2.get());

　　 System.out.println(f3.get());

　　 System.out.println(f4.get());

　　 System.out.println(f5.get());

　　 * 功能：用线程池实现Callable线程对象

　　class myCallable implements Callable String {

　　 private int n;

　　 public myCallable(int n) {

　　 this.n = n;

　　 @Override

　　 public String call() throws Exception {

　　 int sum = 0;

　　 for (int i = 0; i i++) {

　　 sum += i;

　　 return Thread.currentThread().getName() + "计算的1-" + n + "结果为" + sum;

　　方式二：使用Executors（线程池的工具类）调用方法返回不同线程池对象【非重点】

　　Executors工具类底层是ThreadPoolExecutor，但在大型并发系统环境使用Executors可能出现系统风险

 ExecutorService pool = Executors.newFixedThreadPool(固定线程个数)

　　 //底层调用ThreadPoolExecutor，仅有核心线程

　　一种控制任务延时调用，或者周期调用的技术

　　实现方式：：①Timer ②ScheduledExecutorService定时器

　　Timer定时器

Timer timer = new Timer();

　　//schedule还有其他几种重载方式，见jdk

　　timer.schedule(new TimerTask() {

　　 @Override

　　 public void run() {

　　 //线程内容1

　　},0,2000);

　　timer.schedule(new TimerTask() {

　　 @Override

　　 public void run() {

　　 //线程内容2

　　},0,2000);

　　Timer定时器存在的问题

　　1、Timer定时器是单线程，处理多个任务顺序执行，存在延时问题

　　2、因为是单线程，若Timer线程死掉，会影响后续任务执行

　　ScheduledExecutorService定时器

　　ScheduledExecutorService内部是一个线程池,一个任务不会干扰其他任务

　　ScheduledExecutorService在日常开发中更加常用

public static void main(String[] args) {

　　 ScheduledExecutorService timer = new ScheduledThreadPoolExecutor(3);

　　 //scheduleAtFixedRate表示以固定频率定时

　　 timer.scheduleAtFixedRate(new Runnable() {

　　 @Override

　　 public void run() {

　　 System.out.println("定时1" + new Date());

　　 },0,2,TimeUnit.SECONDS);

　　 timer.scheduleAtFixedRate(new Runnable() {

　　 @Override

　　 public void run() {

　　 System.out.println("定时2" + new Date());

　　 },0,3,TimeUnit.SECONDS);

　　线程生命周期

　　以上就是Java多线程并发编程（java多线程并发编程实例）的详细内容，想要了解更多 Java多线程并发编程的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读