黑马程序员——基础篇——多线程

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------

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

/**
采用另一种方法创建两个线程，和主线程交替运行
*/
//需要运行的方法创建类实现Thread。
class Test extends Thread
{

Test(String name)
{
super(name);
}
//覆写run方法
public void run()
{

for(int x = 0; x < 60;x ++)
{
System.out.println("test run..." + x + super.currentThread().getName());
}
}
}

class ThreadTest
{
//主函数
public static void main(String[] args)
{
//创建对象，
Test t1 = new Test("one");
Test t2 = new Test("two");
//调用父类方法，建立两个线程
t1.start();
t2.start();
//主线程
for(int x = 0; x < 60; x ++)
{
System.out.println("main..." + x);
}
}
}
2、实现方式和继承方式
         实现方式的好处：避免了单继承的局限性，在定义线程时，建立使用实现方式。
        两种方式的区别：
               继承Thread：线程代码存放Thread子类run方法中；
               实现Runnable;线程代码存在接口的子类的run方法。

3、多线程的安全问题：
           原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
          解决办法：对多条操作共享数据的语句，只能让一个线程执行完，在执行过程中，其他线程不可以参与执行。
下面的例子为特殊情况造成的死锁，虽然用了synchronized 但还是造成了死锁，所以应避免设计这样的程序。

/**
死锁例子，
*/
//实现Runnable接口
class Test implements Runnable
{
private boolean p;
Test(boolean p)
{
this.p = p;
}

public void run()
{
//线程一为真
if(p)
{
//线程一执行
synchronized(Mylock.locka) //使用锁a
{
System.out.println("if locka");//线程一在此处停止去执行线程二
synchronized(Mylock.lockb)
{
System.out.println("if lockb");
}
}
}
//线程二为假
else
{
//线程二执行
synchronized(Mylock.lockb) //使用锁b，线程一还未使用锁b
{
System.out.println("else lockb");
/*执行结束，锁a被线程一占用无法进入。
到此处后，线程一启动，但是线程二拿着锁b，线程二拿着锁a，导致死锁*/
synchronized(Mylock.locka)
{
System.out.println("else locka");
}
}
}
}
}

class Mylock
{
//创建锁
static Object locka = new Object();
static Object lockb = new Object();
}
public class DeadLock
{
public static void main(String[] args)
{
//创建线程
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
//开启线程
t1.start();
t2.start();
}
}

4、Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。
        Syschronized(对象（可以使用Object类）)
        {
                      需要被同步的代码；
        }
       此处对象为什么必须要建在run函数外部？此对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。
       同步的前提：
      1、必须要有两个或两个以上的线程；
      2、必须是多个线程使用同一个锁；
      3、必须保证同步中只能有一个线程在进行。
好处：解决了多线程的安全问题。
/**
需求：简单的卖票程序。
多个窗口同时卖票

*/
//创建票数的类实现Runnable接口
class Ticket implements Runnable
{
private int tick = 100;
//创建锁
Object object = new Object();
public void run()
{
//同步代码块
synchronized(object)
{
while(true)
{

if(tick > 0)
{
try{Thread.sleep(10);} catch(Exception e) {}
System.out.println(Thread.currentThread().getName() + "sale : " + tick--);
}

if(tick <= 0)
break;
}
}
}
}

class TicketThread
{
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();
}
}
----------android培训、java培训、java学习型技术博客、期待与您交流！------------