多线程基础

 多线程基础

进程和线程

1. 什么是进程

所谓进程（process）就是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元。进程中所包含的一个或多个执行单元称为线程（thread）。

进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。线程只能归属于一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，

该进程会自动申请一个名为主线程或首要线程的线程。操作系统中有若干个线程在"同时"运行。通常，操作系统上运行的每一个应用程序都运行在一个进程中，例如:QQ,IE等等。
注:进程并不是真正意义上的同时运行，而是并发运行。后面我们会具体说明。

2. 什么是线程

一个线程是进程的一个顺序执行流。同类的多个线程共享一块内存空间和一组系统资源，线程本身有一个供程序执行时的堆栈。线程在切换时负荷小，因此，线程也被称为轻负荷进程。

一个进程中可以包含多个线程。

3. 进程与线程的区别

一个进程至少有一个线程。线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程的区别在于每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用来实现进程的调度和管理以及资源分配。
4. 线程使用的场合

线程通常用于在一个程序中需要同时完成多个任务的情况。我们可以将每个任务定义为一个线程，使他们得以一同工作。
例如我们在玩某个游戏时，这个游戏由操作系统运行，所以其运行在一个独立的进程中，而在游戏中我们会听到某些背景音乐，某个角色在移动，出现某些绚丽的动画效果等，这些在游戏中都是同时发生的，但实际上，播放音乐是在一个线程中独立完成的，移动某个角色，播放某些特效也都是在独立的线程中完成的。这些事情我们无法在单一线程中完成。
也可以用于在单一线程中可以完成，但是使用多线程可以更快的情况。比如下载文件。
比如迅雷，我们尝尝会开到它会打开很多个节点来同时下载一个文件。

5. 并发原理

通过上面知识我们知道进程与线程都是并发运行的，那么什么是并发呢?
多个线程或进程”同时”运行只是我们感官上的一种表现。事实上进程和线程是并发运行的，OS的线程调度机制将时间划分为很多时间片段（时间片），尽可能均匀分配给正在运行的程序，获取CPU时间片的线程或进程得以被执行，其他则等待。而CPU则在这些进程或线程上来回切换运行。微观上所有进程和线程是走走停停的，宏观上都在运行，这种都运行的现象叫并发，但是不是绝对意义上的“同时发生。
注1:之所以这样做是因为CPU只有一个，同一时间只能做一件事情。但随着计算机的发展，出现了多核心CPU，例如两核心的CPU可以实现真正意义上的2线程同时运行，但因为CPU的时间片段分配给那个进程或线程是由线程调度决定，所以不一定两个线程是属于同一个进程的，无论如何我们只需要知道线程或进程是并发运行即可。
注2:线程调度机制是OS提供的一个用于并发处理的程序。java虚拟机自身也提供了线程调度机制，用于减轻OS切换线程带来的更多负担。
6. 线程状态

对于程序而言，我们实际上关心的是线程而非进程。通过上面学习的只是，我们了解了什么是线程以及并发的相关知识。那么我们来看看线程在其生命周期中的各个状态:
　　　　　　　　　　　　

New：当我们创建一个线程时，该线程并没有纳入线程调度，其处于一个new状态。
Runnable:当调用线程的start方法后，该线程纳入线程调度的控制，其处于一个可运行状态，等待分配时间片段以并发运行。
Running:当该线程被分配到了时间片段后其被CPU运行，这是该线程处于running状态。
Blocked:当线程在运行过程中可能会出现阻塞现象，比如等待用户输入信息等。但阻塞状态不是百分百出现的，具体要看代码中是否有相关需求。
Dead:当线程的任务全部运行完毕，或在运行过程中抛出了一个未捕获的异常，那么线程结束，等待GC回收

创建线程

 

 创建线程的两种方式

　　1、使用Thread创建线并启动线程

　　2、使用Runnable创建并启动线程

 

1. 使用Thread创建线并启动线程

java.lang.Thread类是线程类，其每一个实例表示一个可以并发运行的线程。我们可以通过继承该类并重写run方法来定义一个具体的线程。其中重写run方法的目的是定义该线程要执行的逻辑。启动线程时调用线程的start()方法而非直接调用run()方法。start()方法会将当前线程纳入线程调度，使当前线程可以开始并发运行。当线程获取时间片段后会自动开始执行run方法中的逻辑。

当调用完start()方法后，run方法会很快执行起来。

run（） 方法是定义线程要完成的任务
Start（） 是用于启动线程使其可以并发运行
同步：有先后顺序的 一般都是在单线程中的
异步：一般在多线程中

/**
 * 测试第一种创造线程的方式
 * 直接集成Thread并重写run方法
 * @author Administrator
 *
 */
public class TestThread {
    public static void main(String[] args) {
        Thread t1 =new Thread();
        Thread t2 =new Thread();
        t1.start();
        t2.start();
    }

}


class MyThread1 extends Thread{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("你是谁啊？");
        }
    }
}
class MyThead2 extends Thread{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是查水表的");
            
        }
    }
}

2. 使用Runnable创建并启动线程

实现Runnable接口并重写run方法来定义线程体，然后在创建线程的时候将Runnable的实例传入并启动线程。
这样做的好处在于可以将线程与线程要执行的任务分离开减少耦合，同时java是单继承的，定义一个类实现Runnable接口这样的做法可以更好的去实现其他父类或接口。因为接口是多继承关系。

/**
 * 第二种 创建线程的方式
 * 实现Runnable，来单独定义线程任务
 * @author Administrator
 *
 */
class TestThrad{
    public static void main(String[] args) {
        Runnable r1 =new MyRunnable1();
        Runnable r2 =new MyRunnable2();
        
        
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        t1.start();
        t2.start();
        
    }
}

/* 什么时候使用Runnable创建线程
     * 1.降低耦合
     * 2.多继承
     * 放在匿名内部类中即可完成
     */
class MyRunnable1 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("我是谁");
        }
    }
}

class MyRunnable2 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("我是顺丰快递啊");
        }
    }
}

3. 使用内部类创建线程

通常我们可以通过匿名内部类的方式创建线程，使用该方式可以简化编写代码的复杂度，当一个线程仅需要一个实例时我们通常使用这种方式来创建。
例如：

/**
 * 使用匿名内部类的方式创建线程
 */
class TestThreadDemo3{
    public static void main(String[] args) {
        //1.继承Thread的方式
        Thread t1 = new Thread(){
            public void run() {
                for(int i=0;i<100;i++){
                    System.out.println("顺丰快递的");
                }
            }
        };
        //2.使用Runnable的方式
     Thread t2 =new Thread(new Runnable(){
         public void run() {
             for(int i=0;i<100;i++){
                    System.out.println("查水表的");
                }
         }
     });
     
     t1.start();
     t2.start();
    }
}

 

实例： 使用线程来切换黑白屏幕的显示

/**
 * 编写一个程序 ，让窗口在白色和黑色间切换
 * @author Administrator
 *1、让TestDemo1 继承自JFrame
 *2、让TestDemo1 实现Runnable接口
 *3、重写run方法，并在方法中切换黑白两色
 *4、在main方法中实例化当前类 设置窗口大小可见
 *5、在线程中启动
 *
 * 使用匿名内部类的方式实现窗口颜色的切换
 * 一个方法的匿名类中，若想引用该方法的其他局部变量，那么这个变量必须是final
 */

class  TestDemo1 {
    public static void main(String[] args) {
        JFrame frame =new JFrame();
        frame.setVisible(true);
        frame.setSize(500,500);    
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.setTitle("manue1");
        frame.setLocation(100,100);
        
        final JPanel panel =new JPanel();
        panel.setSize(300,300);
        frame.setContentPane(panel);
        
        
    
        Thread t =new Thread(new Runnable() {
            public void run() {
                int i=0;
                while (true){
                    i=i==0?1:0;
                    if(i==0){
                        panel.setBackground(Color.BLACK);
                    }else{
                        panel.setBackground(Color.WHITE);
                    }
                }
            }
        });
        t.start();
        
    }


}