线程

从视频中整理：

程序：是对数据描述与操作的代码的集合，是应用程序执行的脚本

进程：是程序的一次执行过程，是系统运行程序的基本单位。

多任务：在一个系统中可以同时运行多个程序，即有多个独立运行的程序，每个任务对应一个进程

线程：比进程更小的运行单位。是程序中单个顺序的控制流。一个进程中可以包含多个线程。

简单来说，线程是一个独立的执行流，是进程内部的一个独立执行单元，相当于一个子程序

一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。

操作系统给每个线程分配不同的CPU时间片，在某一时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行

每个Java程序启动后，虚 拟机将自动创建一个主线程

可以通过以下两种方式自定义线程类：

1.创建java.lang.Thread类的子类，重写该类的run方法

2.创建java.lang.Runnable接口的实现类，实现接口中的run方法

多线程：

package org.jsoft.Thread;

public class ThreadTest {
    public static void main(String[] args) {
        //1.创建线程对象
        FirstThread thread = new FirstThread();
        //2.启动线程
        thread.start();
        for(int i = 0; i < 100; i++){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + ":" + i);
        }
    }
}

class FirstThread extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i = 0; i < 100; i++){
            String firstThreadName = Thread.currentThread().getName();
            System.out.println(firstThreadName + ":" + i);
        }
    }
}
单线程：

package org.jsoft.Thread;

public class ThreadTest {
    public static void main(String[] args) {
        for(int i = 0; i < 100; i++){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + ":" + i);
        }
        //1.创建线程对象
        FirstThread thread = new FirstThread();
        //2.启动线程
        thread.start();
    }
}

class FirstThread extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i = 0; i < 100; i++){
            String firstThreadName = Thread.currentThread().getName();
            System.out.println(firstThreadName + ":" + i);
        }
    }
}
不考虑线程安全的问题，使用Thread类，创建两个线程，共同打印1-100

下面的例子基本上实现了：

package org.jsoft.Thread;

public class ThreadTest1 {
    @SuppressWarnings("static-access")
    public static void main(String[] args) {
        //1.创建线程对象
        SecondThread thread1 = new SecondThread();
        thread1.setI(0);
        //2.启动线程
        thread1.start();
        SecondThread thread2 = new SecondThread();
        thread2.setI(0);
        thread2.start();
    }
}

class SecondThread extends Thread{
    private static int i;
    public static int getI() {
        return i;
    }
    public static void setI(int i) {
        SecondThread.i = i;
    }
    @Override
    public void run() {
        super.run();
        for(; i < 100; i++){
            String firstThreadName = Thread.currentThread().getName();
            System.out.println(firstThreadName + ":" + i);
        }
    }
}

创建多线程：

如果一个类已经显式继承了一个其他的类那就用Runnable接口实现

优势：

1.使用Runnable接口以后还可以为该类继承其他分类

2.适合于资源共享

不考虑线程安全的问题，使用Thread类，创建两个线程，共同打印1-100（使用Runnable接口实现如下：）

package org.jsoft.Thread;

public class TestRunnable implements Runnable{
    int i = 0;

    @Override
    public void run() {
        for(; i < 100; i++){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + ":" + i);
        }
    }
    
    public static void main(String[] args) {
        TestRunnable thread = new TestRunnable();
        Thread t1 = new Thread(thread);
        t1.start();
        Thread t2 = new Thread(thread);
        t2.start();
    }
}

转载于:https://my.oschina.net/u/3686592/blog/2252259