多线程实现原理并发机制

[size=medium][color=red] 进程：[/color][/size]
查询百度大致可以理解为一段具有独立功能的程序，线程是程序中每个部分的代码，一个进程，拥有多个线程，或者子进程。windows 下exe程序就是一个进程。
[size=medium][color=red]线程：[/color][/size]
线程是进程在相同时间分个每个客户单独运行的一段相同程序代码，多线程指的是在程序中同时运行的多个方法片段。
多线程的理解：

[color=orange] 一个类如果实现了Runnable接口或者继承了Thread类，那么它就是一个多线程类，如果是要实现多线程，还需要重写run()方法，所以run() 方法是多线程的入口
但是在启动多线程的时候，不是从run()方法开始的，而是从start()开始的 理由是：当执行多线程的时候，每一个线程会抢占资源，而操作系统会为其分配资源，在start()方法中不仅执行了多线程的代码，除此还调用了一个start0()方法，该方法的声明是native,在Java语言中用一种技术叫做JNI，即JavaNativeInterface，该技术特点是使用Java调用本机操作系统提供的函数，但是有一个缺点是不能离开特定的操作系统，如果线程需要执行，必须有操作系统去分配资源，所以此操作主要是JVM根据不同的操作系统来实现的

如果多线程是通过实现Runnable接口来实现的，那么与通过继承Thread来实现有一个区别，那就是多线程的启动方式——必须是通过start()来启动，但是Runnable接口只有一个方法，并没有start()方法，所以在启动多线程的时候必须调用Thread类的一个构造方法——Thread(Runnable target),该构造方法得到了Runnable接口的一个实现，于是就可以调用Thread类的start()方法了。[/color]

[size=medium][color=red]线程的实现方式：大致3种[/color][/size]

1第一种继承thread：

package com.zk.study.thread;
public class ThreadTest extends Thread {
      private String name;
      public ThreadTest() {
            super();
      }

      public ThreadTest(String name) {
            super();
            this.name = name;
      }
      @Override
      public void run() {
            for(int i=0;i<20;i++){
                  System.out.println(name+":"+i);
            }
      }
}
     2第二种实现runnable接口

package com.zk.study.thread;
public class ThreadsconedTest implements Runnable{
      private String name;
      @Override
      public void run() {
            for(int i=0;i<20;i++){
                  System.out.println(name+":"+i);
            }

      }
      public ThreadsconedTest() {
            super();
      }
      public ThreadsconedTest(String name) {
            super();
            this.name = name;
      }
}

     3 第三种 实现Callable

package com.zk.study.thread;
import java.util.concurrent.Callable;
public class ThreadCallable implements Callable<String> {
      private String name;
      public ThreadCallable(String name) {
            super();
            this.name = name;
      }
      public ThreadCallable() {
      }
      @Override
      public String call() throws Exception {
                  for(int i=0;i<=30;i++){
                        System.out.println(name+":"+i);
                        if(i==20){
                              break;
                        }
                  }
            return "执行够了，不想执行了"+name;
      }
}


主方法，调用线程：

package com.zk.study.thread;
import java.util.concurrent.FutureTask;
public class ThreadDemo {
      /**
       * @param args
       * 线程执行不是通过run方法而是同start方法，run方法是多线程的入口。
       */
      /*public static void main(String[] args) {
            ThreadTest threadA = new ThreadTest("a");
            ThreadTest threadb = new ThreadTest("b");
            threadA.run();
            threadb.run();
      }*/

      /**
       * 第一种线程实现方式实现并发机制 b:10
                   a:17
                   b:11
                   a:18
       * @param args
       */
      /*public static void main(String[] args) {
            ThreadTest threadA = new ThreadTest("a");
            ThreadTest threadb = new ThreadTest("b");
            threadA.start();
            threadb.start();
      }
      */

      /**
       * 第2种实现runable 多线程并发机制
       * B:18
       A:17
       B:19
       A:18
       A:19
       * @param args
       */
      /*public static void main(String[] args) {
            ThreadsconedTest test1 = new ThreadsconedTest("A");
            ThreadsconedTest test2 = new ThreadsconedTest("B");
            Thread t1 = new Thread(test1);
            Thread t2 = new Thread(test2);
            t1.start();
            t2.start();
      }
      */
      /**
       * 实现callable 当我需要执行到某一个时候需要一些返回值得时候
       * @param args
       *
       * 打印结果 A:19
               B:19
               A:20
               B:20
                              执行够了，不想执行了A
                              执行够了，不想执行了B
       */
      public static void main(String[] args) {
            String threadName = null;
            ThreadCallable a= new ThreadCallable("A");
            ThreadCallable b = new ThreadCallable("B");
            FutureTask<String> futureTaska = new FutureTask<String>(a);
            FutureTask<String> futureTaskb = new FutureTask<String>(b);
            Thread t1 = new Thread(futureTaska);
            Thread t2 = new Thread(futureTaskb);
            t1.start();
            t2.start();
            try{
                  threadName = futureTaska.get();//通过get方法可以获取我们想要的返回值
                  System.out.println(threadName);
                  threadName = futureTaskb.get();
                  System.out.println(threadName);
            }catch(Exception e){
                  e.printStackTrace();
            }
      }
}

[size=medium][color=red]三种方式比较：[/color][/size]
　[color=orange]　1.Thread是Runnable接口的子类，实现Runnable接口的方式解决了Java单继承的局限

　　2.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念

3.ThreadCallable需要执行线程时候返回值得时候可以通过这种方式。

目前代码中最好的是实现runnable接口[/color]

[size=medium][color=red]线程的状态以及运行过程：大致有5种[/color][/size]
[color=red]1 创建状态： 准备好一个多线程对象 new thread
2 就绪状态： 调用了start（）方法，等待cpu进行调度,分配资源
3 运行状态： 执行run方法，执行线程完成方法任务。
4 阻塞状态： 暂停执行，可能将资源交给其他线程使用
5 终止状态： 线程销毁[/color]

[size=medium][color=red]线程的常用方法[/color][/size]
[color=orange] 1 取得线程的名称 getName()
2 取得当前线程对象 currentThread()
3 判断线程是否启动 isAlive()
4 线程强行运行 join()
5 线程休眠 sleep()
6 线程的礼让 yield()[/color]
[color=green] 7 线程挂起 suspend()
8 线程恢复 resume()
9 线程等待wait()
10 stop()停止线程[/color]
[color=red] 一般来说后面不怎么使用，容易造成死锁[/color]

package com.zk.study.thread;
class RunnableDemo implements Runnable{
      private String name;
      public RunnableDemo(String name) {
            super();
            this.name = name;
      }
      @Override
      public void run() {
            for(int i=0;i<20;i++){
                  //System.out.println("当前线程对象："+Thread.currentThread().getName());//当前线程名字
                  /*try {
                        Thread.sleep(1000);//沉睡一秒 ，
                  } catch (InterruptedException e) {
                        e.printStackTrace();
                  }*/
                  if(i==10){
                        System.out.println("礼让");/**
                        *a:8
                        a:9
                        礼让
                        true
                        b:0
                        b:1
                        */
                        Thread.yield();//当一个线程执行到时候，礼让另外一个线程执行。
                  }

                  System.out.println(name+":"+i);
            }
      }

}
public class ThreadCommonMethod {
      /**
       *  当前线程对象：Thread-1
            当前线程对象：Thread-0
            当前线程对象：Thread-1
            当前线程对象：Thread-0
            当前线程对象：Thread-1
            当前线程对象：Thread-1
       * @param args
       */
      public static void main(String[] args) {
            RunnableDemo runnableDemo = new RunnableDemo("a");
            RunnableDemo runnableDem01 = new RunnableDemo("b");
            Thread thread = new Thread(runnableDemo);
            Thread thread1 = new Thread(runnableDem01);
            System.out.println(thread.isAlive());// 是否执行当中 false
            thread.start();
            thread1.start();
            System.out.println(thread.isAlive());//true
            /*for(int i=0;i<=20;i++){
                  if(i>10){
                        try {
                              thread.join();// 强制执行线程thread
                                                      // 当主线程执行到大于10的时候强制执行我们的线程，等我们线程执行完在执行主线程
                        } catch (InterruptedException e) {
                              e.printStackTrace();
                        }
                  }
                  System.out.println("主线程："+i);
            }*/
      }
}

[color=orange]线程的优先级 能够帮助当前线程首先抢到cpu资源，但不一定每一次一定抢的到，就是第一个运行。[/color]
[color=red]static intMAX_PRIORITY 线程可以具有的最高优先级。默认10
static intMIN_PRIORITY 线程可以具有的最低优先级。默认1
static intNORM_PRIORITY 分配给线程的默认优先级。默认5[/color]

[size=medium][color=red]同步与死锁：[/color][/size]
[color=orange]1 同步代码块 在代码块上加上synchronized 关键字，此代码块就成为同步代码块
2 同步代码块格式
synchronized（同步对象）{
需要同步代码块
}
3 同步的方法 除了代码块可以同步，方法也可以同步。
4 同步方法的格式
synchronized void 方法名称（）{}[/color]

package com.zk.study.thread;
public class ThreadSynchronized implements Runnable {
      private int ticket =5;
      /**
       * @param args
       */
      public static void main(String[] args) {
            ThreadSynchronized threadSynchronized =new ThreadSynchronized();
            Thread thread1 = new Thread(threadSynchronized);
            Thread thread2 = new Thread(threadSynchronized);
            Thread thread3 = new Thread(threadSynchronized);
            thread1.start();
            thread2.start();
            thread3.start();
      }
      @Override
      public void run() {
            for(int i=0;i<=10;i++){
                  /*synchronized (this) {//同步代码块车票：5 车票：4 车票：3 车票：2 车票：1
                        if(ticket>0){
                              try {
                                    Thread.sleep(500);
                              } catch (InterruptedException e) {
                                    e.printStackTrace();
                              }
                        System.out.println("车票："+  ticket--);//如果不加同步 就会出现负1 车票：0 车票：-1。资源无法共享，这时候就需要加同步。
                        }
                  }*/
                  tell();
            }
      }
      /**
       * 同步方法的执行 5 车票：4 车票：3 车票：2 车票：1
       */
      public synchronized void tell(){
            if(ticket>0){
                  try {
                        Thread.sleep(500);
                  } catch (InterruptedException e) {
                        e.printStackTrace();
                  }
            System.out.println("车票："+  ticket--);//如果不加同步 就会出现负1 车票：0 车票：-1。资源无法共享，这时候就需要加同步。
            }
      }
}