欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

多线程实现原理并发机制 博客分类: java  

程序员文章站 2024-03-13 19:10:27
...
进程:
          查询百度大致可以理解为一段具有独立功能的程序,线程是程序中每个部分的代码,一个进程,拥有多个线程,或者子进程。windows 下exe程序就是一个进程。
线程:
          线程是进程在相同时间分个每个客户单独运行的一段相同程序代码,多线程指的是在程序中同时运行的多个方法片段。
多线程的理解:

         一个类如果实现了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()方法了。


线程的实现方式:大致3种
    
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();
            }
      }
}


三种方式比较:
  1.Thread是Runnable接口的子类,实现Runnable接口的方式解决了Java单继承的局限

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

       3.ThreadCallable需要执行线程时候返回值得时候可以通过这种方式。
  
     目前代码中最好的是实现runnable接口


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


线程的常用方法
    1 取得线程的名称  getName()
     2 取得当前线程对象 currentThread()
     3 判断线程是否启动 isAlive()
     4 线程强行运行 join()
     5 线程休眠 sleep()
     6 线程的礼让 yield()

    7 线程挂起 suspend()
     8 线程恢复 resume()
     9 线程等待wait()
     10 stop()停止线程

    一般来说后面不怎么使用,容易造成死锁
         
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);
            }*/
      }
}


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


同步与死锁:
     1 同步代码块   在代码块上加上synchronized 关键字,此代码块就成为同步代码块
     2 同步代码块格式 
               synchronized(同步对象){
                    需要同步代码块         
                    }
     3 同步的方法  除了代码块可以同步,方法也可以同步。
     4 同步方法的格式
               synchronized void 方法名称(){}

        
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。资源无法共享,这时候就需要加同步。
            }
      }
}