《java开发实战经典》李兴华——C9. 多线程
一、进程与线程
1.进程：进程是程序的一次动态执行过程，包括从代码加载、执行、到执行完毕。
2.线程：线程是比进程更小的执行单位，一个进程可以包括多个线程，这些线程可以同时存在、运行。
进程和线程都是实现并发的基本单位。
Java程序运行时最少2线程：main线程 和 垃圾回收线程。
二、Java中线程的实现
Java中实现多线程的两种手段：1.继承Thread类 2.实现Runnable接口。不管用哪种方法，都要依靠Thread类来实现。
1.继承Thread类：
1）概念：Thread类是在java.lang包中定义的，继承时必需覆写run()方法，此方法为线程的主体。
2）实例：
直接调run()方法实际上没有启动线程
要启动线程，需要调用start()方法
注意：一个实例化对象只能调用一次start()方法，否则会出现IllegalThreadStateException异常
public class Test {
public static void main(String args[]) {
MyThread a1 = new MyThread("first");
MyThread a2 = new MyThread("second");
a1.run();
a2.run();
}
}
class MyThread extends Thread{
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
for(int i = 0;i<10;i++) {
System.out.println(name +"运行，i = "+i);
}
}
//此时未启动线程，按顺序执行，先打印a1的全部，再打印a2。
public class Test {
public static void main(String args[]) {
MyThread a1 = new MyThread("first");
MyThread a2 = new MyThread("second");
a1.start();
a2.start();
}
}
class MyThread extends Thread{
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
for(int i = 0;i<10;i++) {
System.out.println(name +"运行，i = "+i);
}
}
//此时启动线程，a1,a2交替打印。2.实现Runnable接口：
1）概念：
Runnable接口中只定义了一个抽象方法 public void run()。因此可以通过覆写run()方法实现多线程。
2）实例：
实际上还是借助于Thread类，然后调用start()方法。
因为Thread类提供了public Thread(Runnable r)和public Thread(Runnable r,String name)两个构造方法。
public class Test {
public static void main(String args[]) {
MyThread a1 = new MyThread("first");
MyThread a2 = new MyThread("second");
Thread t1 = new Thread(a1);
Thread t2 = new Thread(a2);
t1.start();
t2.start();
}
}
class MyThread implements Runnable{
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
for(int i = 0;i<10;i++) {
System.out.println(name +"运行，i = "+i);
}
}
}3.Thread类和Runnable接口：
1）实际上，Thread和Runnable的子类都同时实现了Runnable接口，之后将Runnable的子类实例放到了Thread类中。
2）继承Thread不适用于多个线程资源共享；实现Runnable接口则可以在多线程间资源共享。
//1.资源不共享
public class Test {
public static void main(String args[]) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
}
}
class MyThread extends Thread{
private int ticket = 5;
@Override
public void run() {
for(int i = 0;i<10;i++) {
if(ticket>0) {
System.out.println("卖票：ticket = "+ticket-- );
}
}
}
}
//卖票：ticket = 5
//卖票：ticket = 5
//卖票：ticket = 4
//卖票：ticket = 4
//卖票：ticket = 3
//卖票：ticket = 2
//卖票：ticket = 1
//卖票：ticket = 3
//卖票：ticket = 2
//卖票：ticket = 1
//2.资源共享
public class Test {
public static void main(String args[]) {
MyThread my = new MyThread();
new Thread(my).start();
new Thread(my).start();
}
}
class MyThread implements Runnable{
private int ticket = 5;
@Override
public void run() {
for(int i = 0;i<10;i++) {
if(ticket>0) {
System.out.println("卖票：ticket = "+ticket-- );
}
}
}
}
//卖票：ticket = 5
//卖票：ticket = 4
//卖票：ticket = 3
//卖票：ticket = 2
//卖票：ticket = 13.）实现Runnable对比继承Thread的优势：
适合多个相同程序代码的线程去处理同一资源的情况。
可以避免由于Java的单继承带来的局限。
增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
因此，建议用实现Runnable。
三、线程的状态
创建、就绪、运行、阻塞、终止。
四、线程操作的相关方法
1）设置当前线程名称，不设时默认分配，格式为Thread-X
Thread.currentThread().setName("线程A")
2）获取当前线程名称
Thread.currentThread().getName();
3）判断线程是否启动,返回true&false
t.isAlive()
4）线程的强制运行，线程强制运行期间，其他线程无法运行，必须等此线程完成。
t.join()
5）线程的休眠
Thread.sleep(500) //休眠500ms
6）中断线程
t.interrupt()
7） 后台线程
t.setDaemon()
8）线程的优先级
Java中所有线程在运行前都会保持在就绪状态，此时哪个线程优先级高，它就会有可能先被执行。
setPriority()可以设置线程的优先级，Java中有3中优先级：
示例：
class MyThread implements Runnable{
@Override
public void run() {
for(int i=0;i<3;i++) {
try {
Thread.sleep(500);//休眠5s
}catch(Exception e) {
}finally {
System.out.println(Thread.currentThread().getName()
+"运行，i ="+i);//输出线程名称
}
}
}
}
public class Test {
public static void main(String args[]) {
//实例化3个线程
Thread t1 = new Thread(new MyThread(),"线程A");
Thread t2 = new Thread(new MyThread(),"线程B");
Thread t3 = new Thread(new MyThread(),"线程C");
//给三个线程设置不同优先级
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t3.setPriority(Thread.NORM_PRIORITY);
//启动三个线程
t1.start();
t2.start();
t3.start();
}
}
//运行结果：
线程B运行，i =0
线程C运行，i =0
线程A运行，i =0
线程B运行，i =1
线程C运行，i =1
线程A运行，i =1
线程B运行，i =2
线程C运行，i =2
线程A运行，i =2
注意：main方法的优先级是NORM_PRIORITY。getPriority()获得当前线程优先级。
9）线程的礼让
Thread.currentThread().yield();//线程礼让：将本线程暂停，让其他线程先执行。
五、线程操作范例
设计一个线程操作类，产生3个线程对象，并设置3个线程的休眠时间，分别是：
线程A：休眠10秒
线程B：休眠20秒
线程C：休眠30秒
1.实现方法一：
class MyThread extends Thread{
private int sleepTime;
public int getSleepTime() {
return sleepTime;
}
public void setSleepTime(int sleepTime) {
this.sleepTime = sleepTime;
}
public MyThread(String name,int sleepTime) {
super(name);
this.setSleepTime(sleepTime);
}
@Override
public void run() {
try {
Thread.sleep(sleepTime);
}catch(Exception e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",休眠"+sleepTime+"豪秒。");
}
}
public class Test {
public static void main(String args[]) {
MyThread t1 = new MyThread("线程A",10000);
MyThread t2 = new MyThread("线程B",20000);
MyThread t3 = new MyThread("线程C",30000);
t1.start();
t2.start();
t3.start();
}
}2.实现方法二：
class MyThread implements Runnable{
private int sleepTime;
public int getSleepTime() {
return sleepTime;
}
public void setSleepTime(int sleepTime) {
this.sleepTime = sleepTime;
}
public MyThread(int st) {
this.setSleepTime(st);
}
@Override
public void run() {
try {
Thread.sleep(sleepTime);
}catch(Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"，休眠"+this.getSleepTime()+"毫秒。");
}
}
public class Test {
public static void main(String args[]) {
Thread t1 = new Thread(new MyThread(1000),"线程A");
Thread t2 = new Thread(new MyThread(2000),"线程B");
Thread t3 = new Thread(new MyThread(3000),"线程C");
t1.start();
t2.start();
t3.start();
}
}六、同步与死锁
1.问题的引出：
通过runnable接口实现多线程，意味着属性会被资源共享。如：产生3个线程，卖5张票：
class MyThread implements Runnable{
private int ticket = 5;
@Override
public void run() {
for(int i =0;i<10;i++) {
if(ticket>0) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("剩余票数："+ticket--);
}
}
}
}
public class Test {
public static void main(String args[]) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
t1.start();
t2.start();
t3.start();
}
}
//运行结果（每次运行结果不相同）：
剩余票数：5
剩余票数：4
剩余票数：5
剩余票数：3
剩余票数：2
剩余票数：3
剩余票数：1
剩余票数：0
剩余票数：-12.问题的解决——同步
所谓同步，指多个操作在同一时间段内只有一个线程进行，其他线程要等待此线程完成后才可以继续进行。
同步操作有两种方式：同步代码块和同步方法。
1）同步代码块
synchronized(同步对象){
需要同步的代码；
}
class MyThread implements Runnable{
private int ticket = 5;
public void run() {
for(int i =0;i<10;i++) {
synchronized (this) {//一般用this指代当前对象
if(ticket>0) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("剩余票数："+ticket--);
}
}
}
}
}
public class Test {
public static void main(String args[]) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
t1.start();
t2.start();
t3.start();
}
}2）同步方法
synchronized 返回值 方法名（参数列表）{
}
class MyThread implements Runnable{
private int ticket = 5;
public void run() {
for(int i =0;i<10;i++) {
this.saleTicket();
}
}
synchronized void saleTicket() {
if(ticket>0) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("剩余票数："+ticket--);
}
}
}
public class Test {
public static void main(String args[]) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
t1.start();
t2.start();
t3.start();
}
}3.死锁
死锁，即两个线程都在等彼此先完成，因此尽量避免过多的同步。
七、线程操作案例——生产者和消费者
生产者生产两种产品：
* 1.李兴华，Java讲师
* 2.mldn,www.mldnjava.cn
消费者依次取走生产者生产的产品。
理想情况下：生产者完整生产一个产品，消费者取一次，然后生产者再生产下一个产品。
应避免的问题：
* 1.产品只生产完一部分就被取走
* 2.生产者生产多次后，消费者才开始取走；或消费者取走后，还没等到新的产品，就再次取了已取过的数据。
一、最简单的想法
/*
* 定义一个产品类
*/
class Product{
private String info1 = "李兴华";
private String info2 = "Java讲师";
public String getInfo1() {
return info1;
}
public void setInfo1(String info1) {
this.info1 = info1;
}
public String getInfo2() {
return info2;
}
public void setInfo2(String info2) {
this.info2 = info2;
}
}
/*
* 定义一个生产者类
*/
class Producer implements Runnable{
private Product p = null;
public Producer(Product p) {
this.p = p;
}
private boolean pF = false;//生产标志，true时生产第一种，false时生产第二种
@Override
public void run() {
for(int i =0;i<10;i++) {
if(pF) {
this.p.setInfo1("李兴华");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.p.setInfo2("java讲师");
pF = false;
}else {
this.p.setInfo1("mldn");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.p.setInfo2("www.mldnjava.cn");
pF = true;
}
}
}
}
/*
* 定义一个消费者类
*/
class Consumer implements Runnable{
private Product p = null;
public Consumer(Product p) {
this.p = p;
}
@Override
public void run() {
for(int i=0;i<10;i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(p.getInfo1()+p.getInfo2());
}
}
}
/*
* 程序入口
*/
public class Test{
public static void main(String[] args) {
Product p = new Product();
Producer per = new Producer(p);
Consumer cer = new Consumer(p);
new Thread(per).start();
new Thread(cer).start();
}
}此时结果：
李兴华,www.mldnjava.cn
mldn,Java讲师
李兴华,www.mldnjava.cn
mldn,Java讲师
李兴华,www.mldnjava.cn
mldn,Java讲师
mldn,Java讲师
李兴华,www.mldnjava.cn
李兴华,Java讲师
李兴华,Java讲师此时问题：
一种产品的内容没设置完整就被取走了。因此应该先保证一个产品能设置完全部内容。解决方法：
1.将设置产品内容的方法进行同步(synchronized set)
2.将获取产品内容的方法进行同步(synchronized get)
3.生产者生产时直接调用set
4.消费者消费时直接调用get二、加入同步，修改以下代码
/*
* 定义一个产品类
*/
class Product{
private String info1 = "李兴华";
private String info2 = "Java讲师";
public String getInfo1() {
return info1;
}
public void setInfo1(String info1) {
this.info1 = info1;
}
public String getInfo2() {
return info2;
}
public void setInfo2(String info2) {
this.info2 = info2;
}
public synchronized void set(String info1,String info2) {
this.setInfo1(info1);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setInfo2(info2);
}
public synchronized void get() {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getInfo1()+this.getInfo2());
}
}
/*
* 定义一个生产者类
*/
class Producer implements Runnable{
private Product p = null;
public Producer(Product p) {
this.p = p;
}
private boolean pF = false;//生产标志，true时生产第一种，false时生产第二种
@Override
public void run() {
for(int i =0;i<10;i++) {
if(pF) {
this.p.set("李兴华", "java讲师");
pF = false;
}else {
this.p.set("mldn", "www.mldnjava.cn");
pF = true;
}
}
}
}
/*
* 定义一个消费者类
*/
class Consumer implements Runnable{
private Product p = null;
public Consumer(Product p) {
this.p = p;
}
@Override
public void run() {
for(int i=0;i<10;i++) {
this.p.get();
}
}
}此时结果：
mldn,www.mldnjava.cn
李兴华,Java讲师
mldn,www.mldnjava.cn
mldn,www.mldnjava.cn
李兴华,Java讲师
mldn,www.mldnjava.cn
mldn,www.mldnjava.cn
李兴华,Java讲师
李兴华,Java讲师
李兴华,Java讲师此时问题：
产品信息错乱解决了，但是还存在重复读写问题。解决方法：
引入等待唤醒机制。
在Product类中加一个标志位，为true时生产，为false时消费。
三、引入等待唤醒机制，修改以下代码
/*
* 定义一个产品类
*/
class Product{
private String info1 = "李兴华";
private String info2 = "Java讲师";
private boolean flag = false;
public String getInfo1() {
return info1;
}
public void setInfo1(String info1) {
this.info1 = info1;
}
public String getInfo2() {
return info2;
}
public void setInfo2(String info2) {
this.info2 = info2;
}
public synchronized void set(String info1,String info2) {
if(!flag) {
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.setInfo1(info1);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setInfo2(info2);
flag = false;
super.notify();
}
public synchronized void get() {
if(flag) {
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getInfo1()+this.getInfo2());
flag = true;
super.notify();
}
}此时结果符合预期，生产一个消费一个。
但是注意：休眠时间的设定，最好在消费前给够生产的时间。
八、线程的生命周期
线程生命周期种的方法已经学过的有：
1.new Thread() 2.start() 3.run() 4.sleep() 5.wait()
接下来介绍：
6.suspend() ：暂时挂起线程 7.resume() ：恢复被挂起的线程 8.stop()：停止线程
这三种方法不推荐使用，因为容易产生死锁问题。
既然不推荐使用，那我们怎么停止一个线程呢？
—— 通过设置标志位的方式，如下：
class MyThread implements Runnable{
private boolean flag = true;
@Override
public void run() {
int i=0;
while(this.flag) {
System.out.println(Thread.currentThread().getName()+"运行，i="+(i++));
if(i > 4) {
this.stop();
}
}
}
public void stop() {
this.flag = false;
}
}
public class Test{
public static void main(String[] args) {
MyThread my = new MyThread();
Thread t = new Thread(my);
t.start();
}
}