黑马程序员——java线程学习笔记

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

                                                                                                                 java线程学习笔记

一、线程的创建

class Test extends Thread            |  class Test implements Runnable

{                                                     |{

     public void run(){}                    |    public void run(){}

}                                                     |}

Thread t = new Test()；                |Thread t = new Thread（(new Test())）；

t.start();                                          |t.start();

以上是java中创建线程的两种方式：1、继承线程类；2、实现runnable接口

二、线程中的常用方法

void sleep(long m)

阻塞当前线程

void interrupt()

线程中断状态被置为true，若在sleep()中则抛出异常。

isInterrupt()

测试线程是否被终止

static Thread currentThread();

返回当前线程

Void setDaemo();

设为守护线程

三、锁对象

确保任何时刻只有一个线程进入临界区，一旦一个线程调用了锁对象，其他任何线程都无法通过lock语句。当其他线程调用lock时，它们被阻塞，直到第一个线程释放锁对象。

Class A{

Lock lock = new ReentrantLock();

public void transfer(){

        lock.lock();

.......

      lock.unlock();

}}

四、条件对象

Condition c = lock.newCondition()

一个锁可以有多个条件对象，条件对象调用await()后，当前线程阻塞，放弃锁。直到另一个线程调用统一条件对象的signalAll()后，再试图重新获得锁重新从阻塞处继续执行。

import java.util.concurrent.locks.Condition

import java.util.concurrent.locks.Lock;

import java.util.conCurrent.locks.ReentranLock;

public class BounderBuffer {

        final Lock   lock = new ReentrantLock();

        final Condition notFull = lock.newCondition();

        final Conditon notEmpty = lock.newCondtion();

        final Object[] items = new Object[100];

        int       putptr,takeptr,count;

        public void put(Object x) throws InterruptedException{

            lock.lock();

            try{

                     while(count == items.length)

                          notFull.await();

                       items[putptr] = x;

                       if(++putptr==items.length)

                              putptr = 0;

                       ++count;

                       notEmpty.signal();

                   }finally{

                          lock.unlock();

                  }

}

    public Object take() throws InterruptedException{

            lock.lock();

            try{

                 while(count == 0)

                      notEmpty.await();

                Object x = items[takeptr];

                if(++takeptr==items.length) 

                      takeptr = 0;

                 --count;

                  notFull.signal();

               return x;}finally{

               lock.unlock();

}  }}

五、Synchronized关键字

1、每一个对象都有一个内部锁，如果一个方法用synchronized声明，那么对象的锁将保护整个方法。

2、内部对象锁只有一个阻塞条件，调用notify和wait()方法实现。

3、每个java对象的内部锁可以通过synchronized（Object o）{}方法获得使用

举例说明： 
     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

public class ThreadDemo implements Runnable { 
     public void run() { 
          synchronized(this) { 
               for (int i = 0; i < 5; i++) { 
                    System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); 
               } 
          } 
     } 
     public static void main(String[] args) { 
          ThreadDemo t1 = new ThreadDemo(); 
          Thread ta = new Thread(t1, "A"); 
          Thread tb = new Thread(t1, "B"); 
          ta.start(); 
          tb.start(); 
     }
}

执行结果：A synchronized loop 0 
     A synchronized loop 1 
     A synchronized loop 2 
     A synchronized loop 3 
     A synchronized loop 4 
     B synchronized loop 0 
     B synchronized loop 1 
     B synchronized loop 2 
     B synchronized loop 3 
     B synchronized loop 4

熟能生巧，多学多用，在使用中将知识融会贯通成为自己的东西