首页 > 代码库 > java多线程基本概述

java多线程基本概述

1.1、概念:

    进程:进程是操作系统结构的基础,是一次程序的执行;是一个程序及其数据再处理器上顺序执行时所发生的活动;是程序再一个数据集合上运行的过程,它是系统进行系统资源分配和调度的最小单元。

    线程:可以理解为一个程序的不同执行路径,是程序执行流的最小单元。线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件,逻辑上可以运行,在等待处理机;运行状态是指线程占有处理机正在运行;阻塞状态是指线程在等待一个事件(如某个信号量),逻辑上不可执行。每一个程序都至少有一个线程,若程序只有一个线程,那就是程序本身。

1.2、使用多线程

    

 1 package soarhu;
 2 
 3 /**
 4  * Created by huaox on 2017/4/17.
 5  *
 6  */
 7 public class Test {
 8     public static void main(String[] args) {
 9         System.out.println(Thread.currentThread().getName());
10     }
11 }

输出结果:main

 

可以知道,在main方法所在的线程即是一个名叫main的线程。

创建线程主要右三种方式:分别为继承Thread类,实现Runnable和Callable接口。

1.2.1:继承Thread

    Thread在jdk文档中定义为: public class Thread implements Runnable 

   使用从Thread继承的最大局限性即是无法实现多继承,所以可以实现Runnable接口或者Callable接口。

 1 package soarhu;
 2 
 3 /**
 4  * Created by huaox on 2017/4/17.
 5  *
 6  */
 7 
 8 class ThreadTest extends Thread{
 9 
10     @Override
11     public void run() {
12         System.out.println("ThreadTest run method: "+Thread.currentThread().getName());
13     }
14 }
15 
16 public class Test {
17     public static void main(String[] args) {
18         System.out.println(" main method : "+Thread.currentThread().getName());
19         Thread thread = new ThreadTest();
20         thread.start();
21         System.out.println("end!!!");
22     }
23 }

   输出结果:

 main method : main

 end!!!
  ThreadTest run method: Thread-0

 从输出结果可以知道:线程之间的代码执行顺序是不可控制的或者说调用顺序是无关的。

1.2.2:实现Runnaball接口

  

package soarhu;

/**
 * Created by huaox on 2017/4/17.
 *
 */

class ThreadTest implements Runnable{

    @Override
    public void run() {
        System.out.println("ThreadTest run method: "+Thread.currentThread().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(" main method : "+Thread.currentThread().getName());
        Thread thread = new Thread(new ThreadTest());
        thread.start();
        System.out.println("end!!!");
    }
}

输出结果与上例一致。

 

1.2.3:实现Callble接口

 Callable接口类似于Runnable,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable可以,可以返回值,这个返回值可以被Future拿到。例子如下

package soarhu;

import java.util.concurrent.*;

/**
 * Created by huaox on 2017/4/17.
 *
 */

class ThreadTest implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("ThreadTest run method: "+Thread.currentThread().getName());
        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        return "hello";
    }

}

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 第一种方式:
      /*
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(new ThreadTest());
        System.out.println("result:" + future.get());
        executor.shutdown();*/

      //第二种方式:
        FutureTask<String> futureTask = new FutureTask<String>(new ThreadTest());
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println("result:" + futureTask.get());
    }
}

  输出结果:hello

 

1.2.4、线程安全

    

package soarhu;

/**
 * Created by huaox on 2017/4/17.
 *
 */

class ThreadTest implements Runnable{

    private int count = 5;


    @Override
    public void run() {
        while (count-->0)
            System.out.println(Thread.currentThread().getName()+" count:-> "+count);
    }


}

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(new ThreadTest(),i+"").start();
        }
    }
}

输出结果:

0 count:-> 4
2 count:-> 4
1 count:-> 4
1 count:-> 3
1 count:-> 2
1 count:-> 1
1 count:-> 0
2 count:-> 3
2 count:-> 2
2 count:-> 1
2 count:-> 0
0 count:-> 3
0 count:-> 2
0 count:-> 1
0 count:-> 0

程序中的count变量是一个成员变量,如果多个线程同时访问则会出现并发问题,但现在这个程序没有出现安全问题是因为:每个线程都访问自己的变量,互补相关。类似于每个人都卖自己的票。

下面修改为多个线程共卖一张票的情况:

  

package soarhu;

/**
 * Created by huaox on 2017/4/17.
 *
 */

class ThreadTest implements Runnable{

    private int count = 5;


    @Override
    public void run() {
        while (count-->0){
            Thread.yield();//让给调度器给其他线程执行的机会。此以方法一般用于debug
            System.out.println(Thread.currentThread().getName()+" count:-> "+count);
        }
    }


}

public class Test {
    public static void main(String[] args) {
        ThreadTest thread = new ThreadTest();
        for (int i = 0; i < 3; i++) {
            new Thread(thread,i+"").start();
        }
    }
}

输出结果:

0 count:-> 4
2 count:-> 2
1 count:-> 2
2 count:-> 0
0 count:-> 1

可见两个线程同时出现了count数为2的情况,也就是两个售货员分别卖出票后,所剩的余票是一样的,这是不允许的,即线程不安全的状况。之所以出现这种情况,是因为某些情况下,i++类似这种操作为非原子操作。可能分为3部分进行。1:获取i的值,2:i+1,3:赋值给i。在这三种情况中。如果有多个线程进行同时访问,那么就会出现安全问题。修改的方式有很多。例如设置为同步块,或者同步方法,显示用Lock锁对象等方式都可以避免。例如:

package soarhu;

/**
 * Created by huaox on 2017/4/17.
 *
 */

class ThreadTest extends Thread{

    private int count = 5;


    @Override
    public  void run() {
        synchronized (ThreadTest.class) {
            if (count-->0) {    //此处应该改为if块,如果为while那么其他线程将得不到执行
                Thread.yield();//让给调度器给其他线程执行的机会。此以方法一般用于debug
                System.out.println(Thread.currentThread().getName() + " count:-> " + count);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        ThreadTest thread = new ThreadTest();
        for (int i = 0; i < 5; i++) {
            new Thread(thread,i+"").start();
        }
    }
}

 输出结果:

0 count:-> 4
1 count:-> 3
4 count:-> 2
3 count:-> 1
2 count:-> 0

可知现在结果输出一切正常!

java多线程基本概述