Java基础<七>_多线程

多线程
一、多线程

1.1、多线程概述

进程与线程：正在运行的程序，就叫做进程。每一个进程的执行都有特定的顺序，每一个顺序都是一个执行路径，也叫做控制单元。进程中具体的执行路线就是线程，也就是说线程在控制着进程的执行，一个进程中至少有一个线程。当一个进程中具有多条线程时，称之为多线程。

JVM启动时有一个进程：java.exe，该进程中至少有一个线程负责java程序的执行；该线程运行main方法中的代码，称为主线程。

扩展：其实JVM启动时不止一个线程，除了主线程外还有专门负责垃圾回收的垃圾回收线程。

好处：多线程可以让程序多部分代码同时执行，提高代码运行效率；多线程有很多应用，例如：迅雷的多任务下载。

线程运行状态：线程可以分为：被创建、运行、冻结、消亡四个状态。其中冻结状态就是线程放弃了执行的资格，没有执行资格；临时(阻塞)状态：具有执行资格，但没有执行权。线程状态之间的切换可以通过特定的方法完成，如下图示：



注意：sleep()方法中需要指定睡眠时间，单位毫秒。

1.2、创建线程的方式

创建线程分为两种方式：1、创建子类继承Thread类；2、创建子类实现Runnable接口。

Java已经提供了对线程的描述，即Thread类。

方式一：创建子类继承Thread类；

步骤：(1)、定义一个类继承Thread类，并复写Thread类中的run()方法；

(2)、创建继承了Thread类的子类对象，这时线程已经被建立；

(3)、调用线程的start()方法，开启线程。

Thread类用于描述线程，该类中定义了一个run()方法用于存储线程要执行的代码，所以：为了新创建的线程有意义，必须复写run()方法。

注意：start()方法可以开启线程，并调用run()方法；run()方法不具备开启线程的功能，仅仅是简单的方法调用。

下面代码演示继承Thread类的创建线程方式：

package itheima.day11;

//演示继承Thread类的创建线程方式
public class ThreadTest {
public static void main(String[] args) {

//		创建线程
Test t1 = new Test("one");
Test t2 = new Test("two");
//		开启线程
t1.start();
t2.start();
//		主线程 main
for(int x=0;x<60;x++){
System.out.println("main run==="+x);
}
}
}
//创建线程类
class Test extends Thread
{
Test(String name){
super(name);
}
//	复写run()方法，写上线程的执行代码
public void run(){
for(int i =0;i<60;i++)
System.out.println(Thread.currentThread().getName()+"  Test run...."+i);
}
}

方式二：创建子类实现Runnable接口；

步骤：(1)、定义一个类实现Runnable接口，并复写runnable接口中的run()方法；

(2)、通过Thread类创建线程，并把实现了Runnable接口的子类对象作为参数

给Thread类的构造函数；

(3)、Thread类对象调用start()方法开启线程。

其实实现Runnable接口的类，只是给出了线程执行的任务(代码)，把这个任务作为构造函数的参数传给一个线程时，才创建一个线程，当把这个任务同时给多个线程时，那么多个线程可以同时操作这个任务，这时就要注意线程安全(同步互斥)问题了。注意：第一种创建线程的方式不可实现多个线程操作同一个任务！

实现方式创建线程可以避免单继承的局限性，所以建议使用实现方式。

1.3、线程安全问题

原因：多线程出现安全问题，是因为多条线程操作同一个共享数据时，一条线程还没执行完，另一条线程却参与进来，最终导致共享数据的操作错误。

解决方法：当操作共享数据时，让一个线程执行完了才让另外的线程参与运行。

如何找问题：1、明确哪些代码是多线程运行代码；2、明确共享数据；3、明确多线程运行代码中哪些语句是操作共享数据的。

Java对于多线程的安全问题提供了专业的解决方式：同步代码块和同步函数。

同步的前提：1、同步需要两个或者以上的线程；2、多个线程使用同一个锁。

同步代码块：格式为：synchronized(对象){需要被同步的代码;}。对象如同锁，只有持有锁的线程才可以在同步中执行。

同步函数：直接在函数上加上synchronized修饰符即可，在同步函数中使用的锁是当前对象this；当同步函数是静态时，静态函数进入内存时，内存中还没有本类对象，所以静态函数的锁不是当前对象，而是本类的字节码文件，类名.class。

死锁：同步的嵌套，可能会发生死锁现象，需注意避免。

下面代码演示：

多线程下的卖票程序：

package itheima.day11;

//需求：简单的卖票程序，多个窗口同时卖票
public class SoldTicket {
public static void main(String[] args) {

Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable
{
private int ticket = 1000;
public void run(){
while(true){
show();
}
}

public synchronized void show(){
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale..." + ticket);
ticket--;
}
}
}

多线程下的单例模式：

package itheima.day11;

//单例设计模式
public class SingleDemo {
public static void main(String[] args) {
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
Single s3 = Single.getInstance();
}
}

//懒汉式
class Single{
private static Single s = null;
private Single(){
System.out.println("Single demo...");
}
public static Single getInstance(){
if(null == s){
synchronized(Single.class){
if(null ==s)
s = new Single();
}
}
return s;
}
}
//饿汉式
/*
class Single{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}*/

1.4、线程间通信

线程间通信：其实就是多个线程在操作同一个资源，但操作动作不同。通常会把这个资源封装成为对象！

等待唤醒机制：等待的线程都存在于线程池中，唤醒的都是线程池中拥有同一把锁的冻结状态线程，notify()方法唤醒的是同一把锁中的任意一个线程，notifyAll()唤醒的是线程池中拥有同一把锁的所有冻结状态线程。

wait()、notify()、notifyAll()等方法都用在同步中，因为要对持有监视器(锁)的线程操作，只有同步才有锁。

为什么操作线程同步的方法定义在Object类中？

因为这些方法在操作同步中的代码时，都必须要标识它们所在线程持有的锁；只有同一个锁上的等待线程可以被同一个锁上的notify唤醒，不可以被不同锁中的notify唤醒；也就是说：等待和唤醒必须是同一个锁，而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

下面代码演示：

演示1：

package itheima.day12;

//演示线程的通信
public class InputOutputDemo {

public static void main(String[] args) {
Resource r = new Resource();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();

}

}
class Resource{
private String name;
private String sex;
boolean flag = false;
public synchronized void set(String name,String sex){
if(flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out(){
if(!flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name+"..."+sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private Resource r ;
Input(Resource r){
this.r = r;
}
public void run(){
int x = 0;
while(true){
if(x==0)
r.set("mike","man");
else
r.set("丽丽","女女女女女");
x = (x+1)%2;
}
}
}
class Output implements Runnable
{
private Resource r ;
Output(Resource r){
this.r = r;
}
public void run(){
while(true){
r.out();
}
}
}

生产者与消费者：

package itheima.day12;

//线程通信;生产者与消费者
public class ProducerConsumerDemo {
public static void main(String[] args) {
//		资源
Res r = new Res();

Producer pro = new Producer(r);//生产者
Consumer con = new Consumer(r);//消费者

Thread t1 = new Thread(pro);//生产者1
Thread t2 = new Thread(pro);//生产者2
Thread t3 = new Thread(con);//消费者1
Thread t4 = new Thread(con);//消费者2

t1.start();//1生产
t2.start();//2生产
t3.start();//1消费
t4.start();//2消费
}
}

class Res{
private String name;
private int count;
private boolean flag = false;
public synchronized void set(String name){
//		if(flag)//醒来不会再次判断标记
while(flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name = name+"---"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者...-------------"+this.name);
flag = true;
//		this.notify();
this.notifyAll();
}
public synchronized void out(){
//		if(flag)//醒来不会再次判断标记
while(!flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
flag = false;
//		this.notify();
this.notifyAll();
}
}
//生产者
class Producer implements Runnable
{
private Res res;
Producer(Res res){
this.res = res;
}
public void run(){
while(true){
res.set("+商品+");//生产
}
}
}
class Consumer implements Runnable
{
//	要消费的资源
private Res res;
Consumer(Res res){
this.res = res;
}
public void run(){
while(true){
res.out();//消费
}
}
}

1.5、线程的停止

分析：stop方法已经过时，那么只有一种方法能停止线程，run方法结束。其实开启多线程运行，运行代码通常是循环结构；只要控制住循环，就可以让run方法结束，也就是停止线程。

特殊情况：当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态，这时需要对冻结状态进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法：interrupt()

下面代码演示：

package itheima.day03;
//演示主线程运行60次之后让t1、t2线程停止
public class StopThreadDemo {

public static void main(String[] args) {
StopThread st = new StopThread();
Thread t1 =new Thread(st);
Thread t2 = new Thread(st);

t1.start();
t2.start();

int num =0;
while(true){
if(num++==60){
//				对冻结状态的线程进行清除
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"..run..."+num);
}
System.out.println("main over");
}
}
class StopThread implements Runnable{
private boolean flag = true;

@Override
public synchronized void run() {
while(flag){
try {
this.wait();
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()
+".....Exception");
}
//			System.out.println(Thread.currentThread().getName()+"....run");
}
}
/*
public void changeFlag(){
flag = false;
}*/
}

1.6、线程的其他方法

1、setPriority(int Priority):设置线程的优先级。

2、setDaemon(boolean b)：守护线程，后台线程。

3、toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

4、join()：加入，当A线程执行到了B线程的join方法时，A会等待，等B线程都执行完，A才会执行。Join可以用来临时加入线程执行。

有关更多方法、更详细解释，可以查询API。