JAVA基础之多线程详解

JAVA基础之多线程详解

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

1、避免点继承的局限，一个类可以继承多个接口。

2、适合于资源的共享

一、通过Thread类来实现多线程
1、定义类继承Thread。
2、复写Thread类中的run方法，目的：将自定义代码存储在run方法。让线程运行。
3、调用线程的start方法，该方法两个作用：启动线程，调用run方法。

<span style="font-size:18px;">public class ThreadDemo {
public static void main(String[] args) {
Test t1 = new Test("one--");
Test t2 = new Test("two++++");
t1.start();	//t1线程
t2.start();	//t2线程
for(int x=0;x<50;x++){	//主线程打印
System.out.println("main--"+x);
}
}
}
class Test extends Thread{ //通过继承Thread来实现多线程！
Test(String name){
super(name);
}
public void run(){
for(int i=0;i<50;i++){
System.out.println(Thread.currentThread().getName()+"run..."+i);
}
}
}</span>

二、通过Runnable接口来实现多线程
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数，为什么要将Runnable接口的子类对象传递给Thread的构造函数。因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。
5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

<span style="font-size:18px;">public class ThreadDemo{
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//实现Runnable接口，或者继承Thread对象
{
private  int tick = 100;
public void run()
{
while(true)
{
if(tick>0)	//如果大于0则显示某个进程卖了哪张票，并自减
{
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
else	//小于0退出
break;
}
}
}</span>

三、线程安全之同步
Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
1、必须要有两个或者两个以上的线程。
2、必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源。

四、生产者消费者详解（代码都有详细注释）

<span style="font-size:18px;">class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r = new Resource();//数据源
Producer pro = new Producer(r);//生产者
Consumer con = new Consumer(r);//消费者
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();

}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)//同步代码块生产
{
while(flag)//判断标记是否有数据，如果true就等待，false就生产
try{this.wait();}catch(Exception e){}//等待
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;		this.notifyAll();//notify往往唤醒的是线程池中的第一个，使用notify会造成死锁，notifyAll是通知所有
}
public synchronized void out()//同步代码块消费
{
while(!flag)//判断标记是否有数据，如果true就消费，false就等待
try{wait();}catch(Exception e){}//等待
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notifyAll();
}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.set("商品--");
}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}</span>

五、新版本生产者及消费者
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized（lock 、unlock、newCondition()）
Condition：替代了Object wait notify notifyAll （await()、signal()、signalAll()）

<span style="font-size:18px;">import java.util.concurrent.locks.*;
class ProducerConsumerDemo2
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();//创建 一个锁对象
private Condition condition_pro = lock.newCondition();//根据锁创建一个Condition对象
private Condition condition_con = lock.newCondition();
public  void set(String name)throws InterruptedException
{
lock.lock();//上锁
try
{
while(flag)
condition_pro.await();//等待
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
condition_con.signal();//唤醒消费者
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}
}
public  void out()throws InterruptedException
{
lock.lock();//上锁
try
{
while(!flag)
condition_con.await();//等待
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
condition_pro.signal();//唤醒生产者
}
finally
{
lock.unlock();//解锁
}

}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("商品--");
}
catch (InterruptedException e)
{
}
}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}</span>