java个人笔记之线程

简介

基本概念

程序 - 表示存放在硬盘/磁盘上的可执行文件。
进程 - 表示运行在内存中的程序。
目前主流的操作系统都支持多线程，但是进程都是重量级的，新建进程对cpu和内存的消耗都比较大，当进程到了一定数量的时候，会造成系统死机等现象。为了减轻cpu和内存的消耗，提出来另外一个概念叫做线程。线程是轻量级的，是录属于进程内部的程序流，当新建线程之后会共享当前进程的资源，而不是申请新的资源，在主流的操作系统中支持线程的。在进程内部又可以支持多线程，多线程可以实现多行代码同时执行的效果，也就是并行的效果。

知识点

线程的并行机制

从主流的操作系统来说，cpu(单核)其实是不可分的，内存空间是可分的，可以将cpu的一段执行时间划分为多个小时间片，然后经每个线程都分配一个小时间片，这样的话，在一段时间内可以做成所有线程都执行的效果，叫做时间片轮转。本质上来说真正的并行并不存在，而是从时间段的角度去考虑是并行的，但是从时间点的角度去考虑是串行的。

常用的构造方法和普通方法

常用的构造方法：
Thread() – 分配新的Thread对象
Thread(Runnable target) – 分配新的Thread对象
Thread(String name) – 分配新的Thread对象
常用的普通方法：
static Thread currentThread()
– 返回当前正在执行的线程对象的引用
long getId() – 返回该线程的标识符，有系统自动生成
String getName() – 返回该线程的名称
void setName(String name) – 设置该线程的名称
void run() – 如果该线程是使用独立的Runnable运行对象构造的，则调用该 Runnable对象的run方法；否则该方法不执行任何操作并返回
void start() – 使该线程开始执行；Java 虚拟机调用该线程的 run 方法

线程创建的方式

线程的两种创建方式

第一种：
继承java.lang.Thread类， 重写run（）方法，并调用start()方法，其中执行main()方法的线程叫做主线程。其中新建出来的线程重新run()方法，并调用start()方法
第二种：
实现Runnable接口，重写run()方法，并调用start()方法。

线程的两种创建方式的注意点

1、继承Thread类的方法相对简单，但是无法再继承其它的类，java支持单继承
2、实现Runnable接口的方式相对比较复杂，但是可以再继承其它的类
3、多线程之间的执行是相互独立的，也就是并行的，但是每个线程内部是串行的

线程的状态

线程中总共有五种状态：
1、新建状态：调用构造方法创建出来的线程的默认状态
2、就绪状态：创建的线程调用start()方法进入的状态；阻塞状态的线程解除阻塞进入的状态；运行状态的线程停止运行进入的状态
3、运行状态：正在运行的线程所处的状态，需要线程调度器来调度；当线程执行完毕之后就回答了就绪状态
4、阻塞状态：暂时停止运行的线程的状态；当线程执行了sleep()方法也可以进入阻塞状态；当线程睡醒了回到就绪状态
5、消亡状态：线程中的所有代码执行完毕的状态

实例

第一种线程创建的实例

创建的线程类：

package com.Thread;

public class Thread1 extends Thread{

    @Override
    public void run(){
        for(int i = 0; i < 10;i ++){
            System.out.println(i);
        }
    }

}       

调用线程的类：

package com.Thread;

public class TestThread {

    public static void main(String[] args){
        Thread1 t1 = new Thread1();
        t1.start();
    }

}

第二种线程创建的实例

创建的线程类：

package com.Thread;

public class Thread2 implements Runnable{

    @Override
    public void run(){
        for(int i = 0; i < 10;i ++){
            System.out.println(i);
        }
    }

}       

调用线程的类：

package com.Thread;

public class TestThread {

    public static void main(String[] args){
        Thread2 t2 = new Thread2();
        Thread thread = new Thread(t2);
        thread.start();
    }

}

相关问题

注意：使用线程时，尽量不产生死锁。死锁发生在两个线程之间，简而言之就是互相占用对方的资源，但是又想获取对象的资源，最终导致了阻塞，也就是死锁。如何解决死锁，可以查看死锁的介绍和解决方法。以下便是死锁的例子：

线程A：

package com.Thread;

public class A extends Thread{

    @Override
    public void run(){
        synchronized(A.class){
            for(int i = 0;i < 15;i ++){
                System.out.println(i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName());
            synchronized(B.class){
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

}

线程B：

package com.Thread;

public class B extends Thread{

    @Override
    public void run(){
        synchronized(B.class){
            for(int i = 0;i < 15;i ++){
                System.out.println(i);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName());
            synchronized(A.class){
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

}