多线程学习总结

多线程

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

 

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。

 

Java的JVM启动的时候会有一个进程java.exe。该进程中至少一个线程负责Java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

 

 

创建线程方式一（继承方式）

步骤：1、定义类继承Tread。

      2、复写Tread类中的run方法。目的：将自定义的代码存储在run方法，让线程运行。

      3、建立子类对象（对象的同时线程也被创建），通过调用start方法开启线程。（线程的start方法能启动线程，调用run方法。Thread类中的run方法，用于存储线程要运行的代码。）

 

class Demo extends Thread

{

public void run()

{

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

System.out.println("demo run----"+x);

}

}

 

class ThreadDemo 

{

public static void main(String[] args) 

{

Demo d = new Demo();//创建好一个线程。

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

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

}

}

 

 

创建线程方式二（实现Runnable接口）

步骤：1、定义类实现Runnable接口；

      2、覆盖Runnable接口中的run方法；将线程要运行的代码存放在该运行run方法中。

      3、通过Thread类建立线程对象；

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

      5、调用Thread类的start方法开启线程并调用Runnable接口子类的Run方法。

class Ticket implements Runnable//extends Thread

{

private  int tick = 100;

public void run()

{

while(true)

{

if(tick>0)

{

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

}

}

}

}

 

class  TicketDemo

{

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();

}

}

 

实现方式和继承方式有什么区别？

继承Thread：线程代码存放在Thread子类run方法中；

实现Runnable：线程代码存放在接口的子类的run方法中。避免了单继承的局限性。

 

同步代码块

synchronized(对象)

{

    需要被同步的代码;

}

同步的前提：

1、必须要有两个或者两个以上的线程。

2、必须是多个线程使用同一个锁。

class Ticket implements Runnable //extends Thread

{

private static int tick =100;

Object obj=new Object();

public void run()

{

while(true)

{

synchronized(obj)

{

if(tick>0)

{

try{Thread.sleep(10);}

catch(Exception e){}

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

}

}

}

}

}

 

class  TicketDemo2

{

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();

}

}

 

 

 

 

 

 

 

 

同步函数使用的锁是this

静态的同步方法，使用的锁是该方法所在类的字节码文件对象：   类名.class

 

class Ticket implements Runnable

{

private static int tick=100;

//Object obj=new Object();

boolean flag=true;

public void run()

{

   if(flag)

   {

       while(true)

   {

   //synchronized(obj)

   //synchronized(this)

     synchronized(Ticket.class)

   {

   if(tick>0)

   {

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

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

}

}

}

}

else

while(true)

show();

}

public static synchronized void show()

{

   if(tick>0)

    {

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

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

    }

}

}

class StaticMethodDemo 

{

public static void main(String[] args) 

{

Ticket t=new Ticket();

        Thread t1=new Thread(t);

Thread t2=new Thread(t);

t1.start();

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

t.flag=false;

t2.start()；

}

}

同步

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

弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

 

同步的前提的：

1，必须要有两个或者两个以上的线程，才需要同步。

2，多个线程必须保证使用的是同一个锁。

 

同步第一种表现形式：

同步代码块

格式：

synchronized(对象) {  // 任意对象都可以。这个对象就是锁。

需要被同步的代码；

}

 

同步的第二种表现形式：

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

 

同步函数的锁：

同步函数所使用的锁就是this。当同步函数被static修饰时，静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。这个对象就是 类名.class

 

同步代码块和同步函数的区别:

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是this

静态同步函数的锁是该类的字节码文件对象：类名.class

 

注意：在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。

 

延迟加载的单例模式

//懒汉式：延迟加载方式。

当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。

为了效率问题，通过双重判断的形式解决。

class Single{

private static Single s = null;

private Single(){}

public static Single getInstance(){ 

if(s == null){

synchronized(Single.class){

if(s == null)

s = new Single();

}

}

return s;

}

}

 

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

 

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

1：将资源封装成对象。

2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

 

等待唤醒机制：涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

 

注意：

1：这些方法都需要定义在同步中。 

2：因为这些方法必须要标示所属的锁。

你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

3：这三个方法都定义在Object类中。因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

 

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

wait：线程会释放执行权，而且线程会释放锁。

Sleep：线程会释放执行权，但不是不释放锁。

 

线程的停止：通过stop方法就可以停止线程。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。

一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

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

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

join：临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

Lock接口（JDK1.5版）

解决线程安全问题使用同步的形式，(同步代码块或同步函数)其实最终使用的都是锁机制。在后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。所以同步是隐示的锁操作，而Lock对象是显示的锁操作，它的出现就替代了同步。

 

在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

 

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。

 

Condition接口：await()、signal()、signalAll()；

class BoundedBuffer {

   final Lock lock = new ReentrantLock();

   final Condition notFull  = lock.newCondition(); 

   final Condition notEmpty = lock.newCondition(); 

   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();

         }

    } 

 }