线程以及线程的创建方式

线程与进程：

       每一个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程，线程可以在程序里独立执行。线程负责在单个程序里执行多任务，通常由操作系统负责多个线程的调度和执行。

       如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换，更多的线程需要更多的内存空间，线程的中止需要考虑对程序运行的影响，通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。

      进程是所有线程的集合，每一个线程是进程中的一条执行路径。

      多线程一般用来提高程序效率，比如（迅雷多线程下载任务，）

    /**
     * 创建多线程的方式：
     * 1：使用继承Thread类方式，重写run方法
     * 2：实现Runnable接口
     * 3：使用匿名内部类方式
     * 4：实现Callable接口
     * 5：使用线程池创建线程
     */

方式1：使用继承Thread类方式，重写run方法：

/**
 * 继承Thread实现多线程
 * @author 91230
 */
class ThreadClass1 extends Thread {

	@Override
	public void run() {
		for (int i=0; i< 30 ;i++) {
			System.out.println("继承Thread创建线程："+i);
		}
	}
}

主函数中创建多线程：

/**
 * 创建多线程
 * @author 91230
 */
public class ThreadDemo01 {
	
	public static void main(String[] args) {
		ThreadClass1 threadClass = new ThreadClass1();
		threadClass.start();
		for (int i=0; i< 30; i++) {
			System.out.println("main线程："+i);
		}
	}
}

程序运行后，我们可以看到结果：

main线程：0
main线程：1
main线程：2
main线程：3
main线程：4
继承Thread创建线程：0
继承Thread创建线程：1
继承Thread创建线程：2
继承Thread创建线程：3
继承Thread创建线程：4
继承Thread创建线程：5
main线程：5
main线程：6
main线程：7
main线程：8
main线程：9
main线程：10
main线程：11
main线程：12
继承Thread创建线程：6
继承Thread创建线程：7
继承Thread创建线程：8
继承Thread创建线程：9
继承Thread创建线程：10
main线程：13
main线程：14
main线程：15
main线程：16
main线程：17
main线程：18
main线程：19
main线程：20
main线程：21
main线程：22
main线程：23
main线程：24
main线程：25
main线程：26
main线程：27
main线程：28
main线程：29
继承Thread创建线程：11
继承Thread创建线程：12
继承Thread创建线程：13
继承Thread创建线程：14
继承Thread创建线程：15
继承Thread创建线程：16
继承Thread创建线程：17
继承Thread创建线程：18
继承Thread创建线程：19
继承Thread创建线程：20
继承Thread创建线程：21
继承Thread创建线程：22
继承Thread创建线程：23
继承Thread创建线程：24
继承Thread创建线程：25
继承Thread创建线程：26
继承Thread创建线程：27
继承Thread创建线程：28
继承Thread创建线程：29

从结果中我们可以看到，当开启ThreadClass1线程后，ThreadClass1线程和main线程交替争夺CPU执行权。当开启多线程后，代码不再从上往下执行了。

方式二：实现Runnable接口：

public class ThreadDemo2 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<10;i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadDemo2线程正在执行："+i);
        }
    }

    public static void main(String[] args) {
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        Thread thread = new Thread(threadDemo2);
        thread.start();
        for (int i=0;i<10;i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main线程正在执行："+i);
        }
        System.out.println("main线程执行完毕");
    }
}

执行结果：

main线程正在执行：0
ThreadDemo2线程正在执行：0
main线程正在执行：1
ThreadDemo2线程正在执行：1
main线程正在执行：2
ThreadDemo2线程正在执行：2
main线程正在执行：3
ThreadDemo2线程正在执行：3
main线程正在执行：4
ThreadDemo2线程正在执行：4
main线程正在执行：5
ThreadDemo2线程正在执行：5
main线程正在执行：6
ThreadDemo2线程正在执行：6
main线程正在执行：7
ThreadDemo2线程正在执行：7
main线程正在执行：8
ThreadDemo2线程正在执行：8
main线程正在执行：9
main线程执行完毕
ThreadDemo2线程正在执行：9

方式3：使用匿名内部类创建

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("A线程："+i);
                }
            }
        },"A");
        thread.start();
        for (int i=0;i<10;i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main线程："+i);
        }
        System.out.println("main线程执行完毕");
    }
}

执行结果：

main线程：0
A线程：0
main线程：1
A线程：1
A线程：2
main线程：2
A线程：3
main线程：3
A线程：4
main线程：4
main线程：5
A线程：5
main线程：6
A线程：6
A线程：7
main线程：7
main线程：8
A线程：8
A线程：9
main线程：9
main线程执行完毕