Java笔记3 多线程<1>线程概述、多线程的创建、多线程的安全问题、静态同步函数的锁、死锁

------- android培训、java培训、期待与您交流！ ----------

11-01-多线程概述

l  进程定义：进程是一个正在执行中的程序。每个进程都有一个执行顺序，该执行顺序做

控制单元。

l  线程定义：线程是进程中独立的一个控制单元。线程在控制着进程的执行。

一个进程中至少有一个线程。

²  多线程存在的意义：多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。

但是多线程并不意味着多个用户进程在执行，操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程，子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间，但保持每个线程拥有独立的执行堆栈和程序执行上下文。

 

 

11-02-创建多线程

l  创建线程有两种方式：继承Thread类和实现Runnable接口。

    第一种方式：继承Thread类。

步骤：

1．定义继承 Thread类。

2．复写Thread类中的run方法。

3．调用线程的start方法。

 

代码示例：

class Demo extends Thread//继承1.Thread类

{

public voidrun()//2.复写run方法

{

for(int i=0;i<60;i++)

{

System.out.println(“Demo run--”+i);

}

}

}

 

public class ThreadDemo

{

public staticvoid main(String[] args)

{

Demo d = new Demo();

d.start();//3.开启线程并执行run方法

//d.run();//仅仅是对象调用方法，而线程创建了并没有执行。

}

 

for(inti=0;i<60;i++)

{

System.out.println(“main--”+i);

}

}

 

多次运行后每一次运行结果都不一样。

原因：多个线程都获取到cpu的执行权，cpu执行到谁，谁就运行。在某一时刻，只有一个程序在运行（多核除外），cpu做着快速的切换，已达到看上去是同时运行的效果，我们可以形象地把多线程的运行行为看成是在互相抢夺cpu的执行权。

²  结论：多线程的一个特点：随机性。谁抢到谁就执行，至于执行多长时间，取决于cpu。

 

 

11-03-线程run和start特点

l  线程run和start的特点

run方法的特点：用于储存线程要运行的代码。

start方法的特点：启动线程并执行该线程的run方法（在启动线程后不一定竞争到cpu的执行权）。

 

 

11-08-创建线程-实现Runnable接口

l  创建线程的第二种方法：实现Runnable接口

步骤：

1．定义类实现Runnable接口。

2．覆盖Runnable接口中的run方法（将线程要运行的代码存放在run方法中）。

3．建立Runnable接口的子类对象。

4．将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

5．调用Thread类的start方法开启并调用Runnable接口。

 

代码示例：

class Ticket implements Runnable//1.实现Runnable接口

{

private int tick= 100;

public voidrun()//2.重写run方法

{

while(true)

{

if(tick>0)

{

System.out.println(Thread.currentThread().getName()+”...sale”+tick--);

}

}

}

}

 

class TicketDemo

{

public staticvoid main(String[] args)

{

Ticket t = new Ticket();//3.创建Runnable接口的子类对象

 

//4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

thread t1 = new Thread(t);

thread t2 = new Thread(t);

thread t3 = new Thread(t);

thread t4 = new Thread(t);

 

//5.调用Thread类的start方法开启线程并调用Runnable接口子类中的run方法

t1.start();

t2.start();

t3start();

t4.start();

}

}

 

l  实现Runnable接口的好处：避免了单继承的局限性，适合于资源共享。

 

 

11-09-多线程的安全问题

通过对11-08代码示例运行结果的分析，出现了打印出0，-1，-2等错票。

11-08示例代码运行结果分析：

(1)运行run方法有四个线程t1、t2、t3、t4。首先t1获取cpu执行权。

(2)当tick = 1时，刚判断完，t1卧倒（t1具备执行资格，但是此刻cpu执行权被其他线程抢走了或是切换到其他程序去了）,t1并没有执行if语句后面代码块中的语句。接着t2获得了cpu执行权，这时的tick = 1，刚判断完，t2也卧倒。t3、t4如同上述情况也处于卧倒状态。

(3)某一时刻，t1获取到了cpu执行权，执行if语句代码块,tick--,tick = 0;

(4)按理说tick = 0，if语句代码块就不在执行，但是t2、t3、t4已经过判断，有执行if语句代码块的资格。t1运行完毕，t2、t3、t4不在经过if语句判断，t2获取cpu执行权，执行if语句代码块,打印0号票，tick--;t2运行完毕，t3获取cpu执行权,打印-1号票，tick--;同理，t4运行打印-2号票。

 

l  问题的原因?

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程就参与进来执行，导致共享数据的错误。

 

l  解决方法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与进来。

 

l  synchronized

同步的前提：

1．必须要有多个（两个或两个以上）线程。

2．必须是多个线程使用同一个锁。（注意：不同线程使用不同锁会出现线程安全问题）

3．必须保证同步中只有一个线程在运行。

 

synchronized的两种表现形式：

1．同步代码块。(对象锁的运用要准确，要不然会出现线程安全问题)

2．同步函数。（经过视频展示，同步函数要运用到位，要不然达不到多线程的目的，因为同步函数一次只能进入一个线程）

同步代码块示例：

synchronized(对象)

{

需要同步的代码块；

}

 

同步函数示例：

public synchronized int add(int a){

//需要同步的函数代码

}

 

²  synchronized的利与弊：

利：解决多线程的安全问题。

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

 

²  小收获：继承接口的run方法，调用sleep()等方法时只能try...catch，不能抛异常。因为接口中的run方法未抛异常。

 

 

11-12-多线程-同步函数的锁是this

l  同步函数用的是哪一个锁呢?

函数需要被对象调用，那么函数都有一个所属对象的引用，就是this。所以同步函数使用的锁是this。

如果一个类里面中既有同步函数又有同步代码块，示例如下：

class Ticket implements Runnable

{

private int tick= 100;

object obj = newObject();

boolean flag =true;

 

public voidrun()

{

if(flag)

{

while(true)

{

//如果synchronized的参数是obj而不是this,在两个或两个以上的线程执行过

//程中就会出现线程安全问题：打印0号票。

synchronized(obj)//<1>

{

if(tick>0)

{

System.out.println(Thread.currentThread().getName()+”...code”+tick--);

}

}

}

}

else

while(true)

{

show();//或是this.show()

}

}

 

publicsynchronized void show()//<2>

{

if(tick>0)

{

System.out.println(Thread.currentThread().getName()+”...show...”+tick--);

}

}

 

public staticvoid main(String[] args)

{

Ticket t = new Ticket();

 

Thread t1 = new Thread(t);

Thread t1 = new Thread(t);

t1.start();

try{Thread.sleep()10;}catch(Exception e){}

t2.start();

t.flag = false;

t2.start();

}

}

 

运行结果表明：在有非静态的同步函数和同步代码块的类中，只有同步代码块中的对象锁为this时，才不会打印出错票的情况。

 

 

11-13-多线程-静态同步函数的锁是class对象

l  如果同步函数被静态修饰符修饰后，使用的锁是什么的呢？

通过验证，发现不是this，因为静态方法中不可以定义this。

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。就是

类名.class,该对象的类型是Class。

 

代码示例：

如果将11-12示例代码中的<2>处改为：public static synchronized voidshow(){...}

那么<1>处应该改为：synchronized(Ticket.class){...}

要不然对象锁不一致会出现线程安全问题：打印出0号票。

 

11-15-多线程-死锁

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

       导致死锁的根源在于不适当地运用“synchronized”关键字来管理线程对特定对象的访问，使同步中嵌套同步。

l  死锁代码举例：

class Test implements Runnable{

    private boolean flag;

    Test(boolean flag){

       this.flag = flag;

    }

 

    public void run(){

       if(flag){

           while(true){

              synchronized(MyLock.locka){

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

                  synchronized(MyLock.lockb){

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

                  }

              }

           }

       }

        else{

           while(true){

              synchronized(MyLock.lockb){

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

                  synchronized(MyLock.locka){

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

                  }

              }

           }

       }

    }

}

 

 

class MyLock{

    static Objectlocka =new Object();

    static Objectlockb =new Object();

}

 

class  DeadLockTest{

    public static void main(String[] args) {

       Thread t1 = new Thread(new Test(true));

       Thread t2 = new Thread(new Test(false));

       t1.start();

       t2.start();

    }

}

 

总结：采用多线程能充分利用CPU资源，提高代码的运行效率。但是在采用多线程的同时必须解决好线程的安全问题：代码同步，避免死锁的出现。

------- android培训、java培训、期待与您交流！ ----------