java编写多线程

一、线程和进程

1、进程：

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

2、线程：

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

3、进程和线程的关系

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
2) 线程的划分尺度小于进程，使得多线程程序的并发性高。
3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
4、并发，并行，串行，同步，异步
并发与并行
并发和并行从宏观上来讲都是同时处理多路请求的概念。但并发和并行又有区别，并行是指两个或者多个事件（多核线程）在同一时刻发生；而并发是指两个或多个事件（进程或者程序）在同一时间间隔内发生。计算机在宏观上并发，微观上并行。
串行和并行：

指的是任务的执行方式。串行是指多个任务时，各个任务按顺序执行，完成一个之后才能进行下一个。并行指的是多个任务可以同时执行。异步是多个任务并行的前提条件。

同步和异步

指的是能否开启新的线程。同步不能开启新的线程，异步可以。个人理解同步是指两个线程的运行是相关的，其中一个线程要阻塞等待另外一个线程的运行。异步的意思是两个线程毫无相关，自己运行自己的。
在I/O流中它们是消息的通知机制。
所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。
异步的概念和同步相对。
当一个异步过程调用发出后，调用者不会立刻得到结果。
实际处理这个调用的部件是在调用发出后，
通过状态、通知来通知调用者，或通过回调函数处理这个调用。
在多线程中，每个线程都可以对互斥资源或者共享资源修改的权利，但是也可以同时修改和访问，这就导致了数据的不安全或者说会造成数据的重复，错误，以及无序等问题。
同步
在多线程环境中，可能会有两个甚至更多的线程试图同时访问一个有限的资源。必须对这种潜在资源冲突进行预防。
解决方法：在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后，其他线程便不能再使用那个资源，除非被解锁。
这里的锁有很多种，这里就不一一介绍了。
二、java多线程编程
java中实现多线程的方法，有人说两种，有人说三种，本博客用三种方法来介绍，同时加上同步锁。
1、继承Thread方法

//创建一个类，继承Thread类
public class NewThread extends Thread{
    @Override
    public void run() {
//      获得当前的线程名称
        System.out.println("当前线程的名字是："+Thread.currentThread());

    }
}

public class TestThread {

    public static void main(String[] args) {
//      创建线程
        NewThread thread1= new NewThread();
        NewThread thread2= new NewThread();
        NewThread thread3= new NewThread();
//      开启线程
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

2、实现Runnable接口

public class NewRunnable implements Runnable {

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("当前的线程名字："+Thread.currentThread().getName());

        }

    }
}

public class TestRunnble {

    public static void main(String[] args) {
//      创建线程对象
        NewRunnable runnable=new NewRunnable();
//      开启线程
        Thread thread1=new Thread(runnable);
        Thread thread2=new Thread(runnable);
        Thread thread3=new Thread(runnable);
        Thread thread4=new Thread(runnable);
        Thread thread5=new Thread(runnable);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();

    }

}

3、使用ExecutorService、Callable、Future实现有返回结果的多线程

package thread.excute;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Scanner;
import java.util.concurrent.Callable;
//创建一个类实现Callable接口
public class SearchByImplementsCallable implements Callable {
    private String word;
    private String path;
    private SearchByImplementsCallable(String word ,String path){
        this.word=word;
        this.path=path;
    }
    public static SearchByImplementsCallable setInstance(){
        Scanner input = new Scanner(System.in);

        System.out.print("请输入你要查找的单词：");
        String word = input.next();
        Properties pro = new Properties();
        try
        {
            pro.load(new FileReader("E:/work/IO/src/com/sbdqn/search/path.properties"));
        } catch (IOException e)
        {
            e.printStackTrace();
        }
        String path = pro.getProperty("path");
        SearchByImplementsCallable search= new SearchByImplementsCallable(word,path);
        return search;
    }


    private static int total =0;
    @Override
    public Object call() throws Exception {
        File file= new File(path);
        BufferedReader br=null;
        String str=null;
        try
        {
            FileReader fr = new FileReader(file);
            br = new BufferedReader(fr);
            while((str=br.readLine())!=null){
                //输出文件 的内容
//                  正则表达式中\s匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]，切割字符串形成字符串数组  
//              [^A-Za-z0-9'] 按照标点符号来划分
            //String [] st=str.split("\\s+|[^A-Za-z0-9']");
                String[] st = str.split("[^a-zA-Z0-9']");
                int i = 0;
                for (String stri : st) {

//                  System.out.println(stri);
                    if (stri.equalsIgnoreCase(word)) {
                        i++;
                        total++;
                    }

                }
//              System.out.println("该行总共有" + i + "个" + word);
//              System.out.println("该文档截止现在总共有" + total + "个" + word);
            }
        }

        catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("找不到该文件。");
        }

        if(br!=null){
            try
            {
                br.close();
            } catch (IOException e)
            {
                System.out.println("无法关闭。");
            }
        }
        return total;


    }

}

package thread.excute;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;



/**
 * 这是一个具有读取文件流和统计单词数量的类
 * @author Lian Jingwei
 *
 */
@SuppressWarnings("unused")
public class Statistics
{
    /**
     * 设置类变量
     */
    private static int total =0;
    /**
     * 这是一个统计输入单词在特定文件中的数量
     * @param word
     * @param path
     * @return total
     * @throws IOException 
     */
    public int statisticsNum(String word , String path)  {
        long stateTime=System.currentTimeMillis();
        File file= new File(path);
        BufferedReader br=null;
        String str=null;
        try
        {
            FileReader fr = new FileReader(file);
            br = new BufferedReader(fr);
            while((str=br.readLine())!=null){
                //输出文件 的内容
//                  正则表达式中\s匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]，切割字符串形成字符串数组  
//              [^A-Za-z0-9'] 按照标点符号来划分
            //String [] st=str.split("\\s+|[^A-Za-z0-9']");
                String[] st = str.split("[^a-zA-Z0-9']");
                int i = 0;
                for (String stri : st) {

//                  System.out.println(stri);
                    if (stri.equalsIgnoreCase(word)) {
                        i++;
                        total++;
                    }

                }
//              System.out.println("该行总共有" + i + "个" + word);
//              System.out.println("该文档截止现在总共有" + total + "个" + word);
            }
        }

        catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("找不到该文件。");
        }

        if(br!=null){
            try
            {
                br.close();
            } catch (IOException e)
            {
                System.out.println("无法关闭。");
            }
        }
        long stopTime=System.currentTimeMillis();
        System.out.println("运行所需要的时间是："+(stopTime-stateTime));

        return total;

    }



}

package thread.excute;


import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class test {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        Scanner input =new Scanner(System.in);
        System.out.print("请输入你所需要创建的线程数(整数)：");
        int num=input.nextInt();
/*      创建线程池，newFixedThreadPool()创建可重用且固定线程数的线程池，如果线程池中的所有线程
 * 都处于活动状态，
        * 此时再提交任务就在队列中等待，直到有可用线程；如果线程池中的某个线程
        * 由于异常而结束时，线程池就会再补充一条新线程。
        * */

        ExecutorService excutor =Executors.newFixedThreadPool(num);
//      创建对象
        SearchByImplementsCallable instance=SearchByImplementsCallable.setInstance();
        @SuppressWarnings("unchecked")
//      将对象放进线程池，并启动线程，并返回线程结果
        Future future =excutor.submit(instance);
//      关闭线程
        excutor.shutdown();
//      输出Future结果
        try {
            System.out.println("文档中所含"+future.get()+"个你所输入的单词");
        } catch (Exception e) {
            e.printStackTrace();
        } 

        long stopTime = System.currentTimeMillis();
        long time =stopTime-startTime;
        System.out.println("运行的时间是："+time);
    }


}