Java 多线程--- 创建线程、Thread类、synchronized

最新推荐文章于 2021-02-24 11:43:29 发布

weixin_30381317

最新推荐文章于 2021-02-24 11:43:29 发布

阅读量83

点赞数

文章标签： java 操作系统

原文链接：http://www.cnblogs.com/hesier/p/5628937.html

版权

在Java中，一个应用程序对应着一个JVM实例（JVM进程），一般来说名字默认为java.exe或者javaw.exe（windows下可以通过任务管理器查看）。Java采用的是单线程编程模型，即在我们自己的程序中如果没有主动创建线程的话，只会创建一个线程，通常称为主线程。但是，虽然只有一个线程来执行任务，不代表JVM中只有一个线程，JVM实例在创建的时候，同时会创建很多其他的线程（比如垃圾收集器线程）。
一个进程包括多个线程，这些线程是共同享有进程占有的资源和地址空间的。进程是操作系统进行资源分配的基本单位，而线程是操作系统进行调度的基本单位。

一、线程创建

创建线程类（继承Thread或实现Runnable接口）
创建线程对象thread（如果通过实现Runnable创建线程类，则要需要将Runnable作为Thread类的参数）
通过start方法启动

// 继承Thread
class MyThread extends Thread{
    private static int num = 0;
    public MyThread(){
        num++;
    }
    
    @Override
    public void run(){
        System.out.println("主动创建的第"+num+"个线程");
    }
}

public class Test{
    public static void main(String[] args){
        MyThread thread = new MyThread();
        thread.start();
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable{
    public MyRunnable(){}
    @Override
    public void run(){
        System.out.println("子线程ID:" + Thread.currentThread().getId());
    }
}

public class Test{
    public static void main(String[] args){
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

二、Thread 类

1、线程的状态

　　创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）

线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件（比如内存资源:程序计数器、Java栈、本地方法栈都是线程私有的，所以需要为线程分配一定的内存空间），只有线程运行需要的所有条件满足了，才进入就绪状态。
当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其他的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。
线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。
当由于突然中断或者子任务执行完毕，线程就会被消亡。

线程间进行上下文切换的时候会记录程序计数器、CPU寄存器状态等数据。

2、Thread类中常用方法：

start方法。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。
run方法。run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。即start()内部调用了run()方法。直接调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动。
sleep方法。sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。但是有，sleep方法不会释放锁，也就是说如果当前线程持有某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。
yield方法。调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间。
join方法。假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的时间。实际上调用join方法是调用了Object的wait方法，wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。
interrupt方法。调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就说，它可以用来中断一个正处于阻塞状态的线程。但是直接调用interrupt方法不能中断正在运行中的线程。
静态方法currentThread()用来获取当前线程。
setDaemon和isDaemon 用来设置线程是否成为守护线程和判断线程是否是守护线程。守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

　　注意：wait，notify，notifyAll是属于Object。

　　只能在同步方法或者同步块中使用wait()方法。在执行wait()方法后，当前线程释放锁（这点与sleep和yield方法不同）。调用了wait函数的线程会一直等待，直到有其他线程调用了同一个对象的notify或者notifyAll方法才能被唤醒，需要注意的是：被唤醒并不代表立刻获得对象的锁，要等待执行notify()方法的线程执行完，即退出synchronized代码块后，当前线程才会释放锁，而呈wait状态的线程才可以获取该对象锁。

　　如果调用wait()方法时没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch语句进行捕获异常。notify方法只会（随机）唤醒一个正在等待的线程，而notifyAll方法会唤醒所有正在等待的线程。如果一个对象之前没有调用wait方法，那么调用notify方法是没有任何影响的。

三、synchronized

1.synchronized方法

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public void insert(Thread thread){
        for(int i=0; i<5; i++){
            System.out.println(thread.getName()+"insert number " + i);
            list.add(i);
        }
    }
}

public class Test{
    public static void main(String[] args){
        final InsertData insertData = new InsertData();
        new Thread(){
            public void run(){
                insertData.insert(Thread.currentThread());
            }
        }.start();
        
        new Thread(){
            public void run(){
                insertData.insert(Thread.currentThread());
            }
        }.start(); 
    }
}

输出结果为：

给insert 方法加上synchronized 关键字

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public synchronized void insert(Thread thread){
        for(int i=0; i<5; i++){
            System.out.println(thread.getName()+"insert number " + i);
            list.add(i);
        }
    }
}

输出结果为：

当一个线程正在访问一个对象的synchronized方法，那么其他线程不能访问该对象的其他synchronized方法。因为一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized方法。
当一个线程正在访问一个对象的synchronized方法，那么其他线程能访问该对象的非synchronized方法。因为访问非synchronized方法不需要获得该对象的锁，假如一个方法没用synchronized关键字修饰，说明它不会使用到临界资源，那么其他线程是可以访问这个方法的。

2.synchronized代码块

synchronized(synObject){
    
}

synObject可以是this，代表获取当前对象的锁，也可以是类中的一个属性，代表获取该属性的锁。

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public void insert(Thread thread){
        synchronized(this){
            for(int i=0; i<5; i++){
                System.out.println(thread.getName()+"insert number " + i);
                list.add(i);
            }
        }
    }
}

或者：

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    private Object object = new Object();
    
    public void insert(Thread thread){
        synchronized(object){
            for(int i=0; i<5; i++){
                System.out.println(thread.getName()+"insert number " + i);
                list.add(i);
            }
        }
    }
}

总结就是：

当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。

举例：

class MyRunnable implements Runnable{
    @Override
    public void run(){
        synchronized(this){
            try{
                for(int i=0; i<5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop "+i);
                }
            }catch (InterruptedException ie){
                
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Runnable demo = new MyRunnable();
        Thread t1 = new Thread(demo, "t1");
        Thread t2 = new Thread(demo, "t2");
        t1.start();
        t2.start();
    }
}

t1和t2都是基于"demo这个Runnable对象"创建的线程，我们可以将synchronized(this)中的this看作是“demo这个Runnable对象”。因此，线程t1和t2共享“demo对象的同步锁”。

结果：

t1 loop 0
t1 loop 1
t1 loop 2
t1 loop 3
t1 loop 4
t2 loop 0
t2 loop 1
t2 loop 2
t2 loop 3
t2 loop 4

但是，如果

class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run(){
        synchronized(this){
            try{
                for(int i=0; i<5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop "+i);
                }
            }catch (InterruptedException ie){
                
            }            
        }
    }
}

public class Test{
    public static void main(String[] args){
        Thread t1 = new MyThread("t1");
        Thread t2 = new MyThread("t2");
        t1.start();
        t2.start();
    }
}

t1和t2是两个不同的MyThread对象，因此t1和t2在执行synchronized(this)时，获取的是不同对象的同步锁。

结果：

t1 loop 0
t2 loop 0
t1 loop 1
t2 loop 1
t1 loop 2
t2 loop 2
t1 loop 3
t2 loop 3
t1 loop 4
t2 loop 4

3、全局锁

如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁（全局锁），而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。

pulbic class Something {
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}