多线程

1.1      多线程介绍

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

1.2      Thread类

通过API中搜索，查到Thread类。通过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

l  构造方法

l  常用方法

发现创建新执行线程有两种方法。

一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。

另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

创建线程的步骤：

1 定义一个类继承Thread。

2 重写run方法。

3 创建子类对象，就是创建线程对象。

4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

package com.oracle.xiancheng;

public class Demo01 extends Thread {

public static void main(String[] args) {

//创建线程

MyThread mt=new MyThread();

//创建线程

mt.start();

//获取正在执行的对象名称  调用 getname

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

System.out.println("main-------"+i);

}

}

}

自定义线程类

package com.oracle.Runnable;

public class MyRunnable implements Runnable{

@Override

public void run() {

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

System.out.println("run-----"+i);

}

}

}

1.2.1    实现Runnable的原理

实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。

创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.2.2    实现Runnable的好处

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.3      线程的匿名内部类使用

package com.oracle.Runnable;

public class MyRunnable implements Runnable{

@Override

public void run() {

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

System.out.println("run-----"+i);

}

}

}

package com.oracle.Runnable;

public class Demo02 {

public static void main(String[] args) {

//创建线程子类对象

//匿名内部类对象

//创建线程对象时，直接重写Thread类中的run方法

Thread th=new Thread(){

public void run() {

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

};

};

//开启线程

th.start();

//使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法

/*Runnable r=new Runnable(){

public void run() {

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

};

};

//创建线程任务对象

Thread th=new Thread(r);

//开启线程

th.start();*/

}

}

运行结果：

线程池

2.1      线程池概念

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源

2.2      使用线程池方式--Runnable接口

l  Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

l  ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

l  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

l  使用线程池中线程对象的步骤：

创建线程池对象

创建Runnable接口子类对象

提交Runnable接口子类对象

关闭线程池

package com.oracle.Runnable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Demo03 {

public static void main(String[] args) {

// Executors 线程池工厂类

// ExecutorService 线程池工厂类

// 获取线程池对象

ExecutorService es = Executors.newFixedThreadPool(2);

// 创建线程任务对象

MyRunnable mr = new MyRunnable();

// 执行线程任务

es.submit(mr);

es.submit(mr);

es.submit(mr);

//释放资源

es.shutdown();

}

}

package com.oracle.Runnable;

public class MyRunnable implements Runnable{

@Override

public void run() {

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

System.out.println("run-----"+i);

}

}

}

运行结果：

等等

2.3      使用线程池方式—Callable接口

Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

ExecutorService：线程池类

<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：

创建线程池对象

创建Callable接口子类对象

提交Callable接口子类对象

关闭线程池

package com.oracle.Runnable;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

@Override

public String call() throws Exception {

return "abc";

}

}

package com.oracle.Runnable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Demo04 {

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

//创建线程任务

MyCallable mc=new MyCallable();

//获取线程池工厂

ExecutorService es=Executors.newFixedThreadPool(2);

Future<String> f=es.submit(mc);

//创建返回值

String  str=f.get();

System.out.println(str);

}

}

运行结果：

2.4      线程池练习：返回两个数相加的结果和乘积的结果

和

package com.oracle.Demo01;

import java.util.concurrent.Callable;

public class MyCallables implements Callable<Integer> {

private int num1;

private int num2;

public MyCallables(int num1,int num2) {

this.num1=num1;

this.num2=num2;

}

@Override

public Integer call() throws Exception {

return num1+num2;

}

}

package com.oracle.Demo01;

import java.math.BigInteger;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Test1 {

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

//和

MyCallables mc1=new MyCallables(100,150);

MyCallables mc2=new MyCallables(10,15);

ExecutorService es=Executors.newFixedThreadPool(2);

Future<Integer> num1=es.submit(mc1);

Future<Integer> num2=es.submit(mc2);

int s1=num1.get();

int  s2=num2.get();

System.out.println(s1);

System.out.println(s2);

es.shutdown();

}

}

运行结果：

积：

package com.oracle.Demo01;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.concurrent.Callable;

public class MyCallablesr implements Callable<String > {

private int num;

public MyCallablesr(int num) {

this.num=num;

}

@Override

public String call() throws Exception {

String  base="1";//超long的范围

for(int i=1;i<=num;i++){

//用BigDecimal转换

BigDecimal stra=new BigDecimal(base);

BigDecimal end=new BigDecimal(i);

BigDecimal re=end.multiply(stra);

base=re.toString();

}

return base ;

}

}

package com.oracle.Demo01;

import java.math.BigInteger;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Test1 {

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

//积

MyCallablesr ms1=new  MyCallablesr(100);

MyCallablesr ms2=new MyCallablesr(200);

ExecutorService es=Executors.newFixedThreadPool(2);

Future<String> base1=es.submit(ms1);

Future<String> base2=es.submit(ms2);

String s1=base1.get();

String s2=base2.get();

System.out.println(s1);

System.out.println(s2);

es.shutdown();

}

}

运行结果：

多线程

3.1      线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

l  我们通过一个案例，演示线程的安全问题：

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “功夫熊猫3”，本次电影的座位共100个(本场电影只能卖100张票)。

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

3.2      线程同步（线程安全处理Synchronized）

java中提供了线程同步机制，它能够解决上述的线程安全问题。

线程同步的方式有两种：

方式1：同步代码块

方式2：同步方法

3.2.1    同步代码块

同步代码块: 在代码块声明上 加上synchronized

synchronized (锁对象) {

可能会产生线程安全问题的代码

}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

模拟售票：

package com.oracle.xianchengchi;

public class MyRunnable implements Runnable {

// 卖电影票

private int ticket = 100;

private Object obj = new Object();

@Override

public void run() {

while (true) {

synchronized (obj) {

if (ticket > 0) {

try {

Thread.sleep(50);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");

}

}

}

}

}

测试：

package com.oracle.xianchengchi;

public class Test01 {

public static void main(String[] args) {

//明确线程任务

MyRunnable mr=new MyRunnable();

Thread t0=new Thread(mr);

Thread t1=new Thread(mr);

Thread t2=new Thread(mr);

//开启线程

t0.start();

t1.start();

t2.start();

}

}

运行结果：

3.2.2    同步方法

l  同步方法：在方法声明上加上synchronized

public synchronized void method(){

可能会产生线程安全问题的代码

}

         同步方法中的锁对象是 this

使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改：

package com.oracle.xianchengchi;

public class MyRunnables implements Runnable {

// 卖电影票

private int ticket = 100;

private Object obj = new Object();

@Override

public void run() {

while (true) {

sale();

}

}

public synchronized void sale() {

if (ticket > 0) {

try {

Thread.sleep(50);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");

}

}

}

package com.oracle.xianchengchi;

public class Test02 {

public static void main(String[] args) {

//明确线程任务

MyRunnables mr=new MyRunnables();

Thread t0=new Thread(mr);

Thread t1=new Thread(mr);

Thread t2=new Thread(mr);

//开启线程

t0.start();

t1.start();

t2.start();

}

}

运行结果：

3.3      Lock接口

查阅API，查阅Lock接口描述，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

l  Lock接口中的常用方法

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

package com.oracle.xianchengchi;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class MyRunnable2 implements Runnable {

// 卖电影票

private int ticket = 100;

private Lock lock=new ReentrantLock();

@Override

public void run() {

while (true) {

lock.lock();

if (ticket > 0) {

try {

Thread.sleep(50);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");

}

lock.unlock();

}

}