java多线程设计模式——学习笔记(1)java语言的线程

最新推荐文章于 2024-03-16 09:00:00 发布

k763925053

最新推荐文章于 2024-03-16 09:00:00 发布

阅读量695

点赞数

分类专栏： java 多线程

本文链接：https://blog.csdn.net/k763925053/article/details/25047665

版权

java 同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

多线程

2 篇文章 0 订阅

订阅专栏

何谓线程？

线程（Thread）的英语原意为“细丝”，java语言把“正在执行程序的主体”称为线程（Thread）。

单线程指的是正在执行程序的主体只有一个。而 多线程正在执行程序的主体为1个以上。

多线程应用的几个场所：

GUI应用程序
比较花费时间的I/O处理
多个客户端

启动线程的方式：

MyThread thread = new MyThread();
thread.start();

调用start()方法会有两个操作：（1）启动新线程；（2）调用run方法

注意：直接调用run方法并不会启动一个新线程，要启动新线程必须调用start()方法。

并行与并发：

当有一个以上的线程在操作时，如果计算机只有一个处理器，则程序会不断来回切换有操作的线程，这种操作被称为并发（concurrent）；如果计算机有多个处理器，则线程的操作就有可能是并行（parallel）而非并发处理的。表现并发和并行两者差异的模式如下图所示。

线程启动的两种方式：

利用Thread的子类实例启动线程
利用Runnable接口的实现类实例启动线程

线程的共享互斥：

在多线程程序里，多个线程既然可以自由操作，当然就可能同时操作到同一实例。这个情况又是会造成不必要的麻烦。例如经典的银行取款问题，其“确认可用余款”这一部分的代码应该该为：

if(可用余额大于欲提取金额)  
{  
  从可用余额中减掉欲提取金额  
}

先确认可用余额是否大于欲提取金额，如果是，则可提取金额，这样就保证不会出现负数的情况。但是，如果让2个线程同时执行这段代码，就有可能出现余额变成负数的情况。具体如下图所示：

我们发现，由于时间差，可能会发生线程B夹在线程A的“确认可用余额”和“减去可用余额”之间的情况，这就会导致出现金额为负数的情况。

这时候就需要一种“交通管制”来避免此类问题的出现。JAVA中使用synchronized来实现共享互斥。这就好比十字路口的红绿灯处理一样；当直向行车时绿灯时，另一边的横向车灯一定是红灯。synchronized也采用类似的“交通管制”的方式来实现线程间的互斥。

因此，上述银行取款问题的代码如下：

public class Bank  
{  
    private int money;  
    private String name;  
  
    public Bank(String name, int money)  
    {  
        this.money = money;  
        this.name = name;  
    }  
  
    // 存款  
    public synchronized void deposit(int m)  
    {  
        money += m;  
    }  
  
    // 取款  
    public synchronized void withdraw(int m)  
    {  
        if (money >= m)  
        {  
            money -= m;  
            return true;  // 已取款  
        }  
        else  
        {  
            return false; // 余额不足  
        }  
    }  
  
    public String getName()  
    {  
        return name;  
    }  
}

当一个线程正在执行Bank实例的deposit或withdraw方法时，其他线程就不能执行同一实例的deposit以及withdraw方法。欲执行的线程必须排队等候。
也许会注意到，Bank类里还有一个非synchronized的方法——getName。无论其它线程是否正在执行同一实例的deposit、withdraw或者getName方法，都不妨碍它的执行。

一个实例的synchronized方法只能允许1次一个线程执行。但是非synchronized的方法却没有这个限制。

当某1个线程执行synchronized方法时，该线程即取得该实例的锁定，其他线程则不能再执行同一实例的synchronized方法(所有synchronized方法)。

synchronized阻挡(又称synchronized语句)

synchronized局部阻挡：如果需要“管制”的不是整个方法，而是方法的一部分，就使用此类阻挡，代码如下：

synchronized(表达式)  
{  
    ……  
}

synchronized实例方法阻挡：如果需要“管制”的是整个实例方法，而是方法的一部分，就使用此类阻挡，代码如下：

synchronized void method()  
{  
    ……  
}

这段代码在功能上与如下代码有异曲同工之妙：

void method()  
{  
    synchronized(this)      
    {  
        ……  
    }  
}

synchronized类方法阻挡：如果需要“管制”的是类方法，就使用此类阻挡，代码如下：

class Something  
{  
    static synchronized void method()  
    {  
        ……  
    }  
}

这段代码在功能上与如下代码有异曲同工之妙：

class Something  
{  
    static void method()  
    {  
        synchronized(Something.class)  
        {  
            ……  
        }  
    }  
}

也就是说，synchronized类方法是使用该类的类对象锁定去做线程的共享互斥。

线程的协调：

wait set——线程的休息室：所有实例都有一个wait set，wait set是一个在执行该实例的wait方法时，操作停止的线程的集合（每个实例都有）。

obj.wait()是将现在的线程放到obj的wait set中；
obj.notify()是从obj的wait set中唤醒一个线程；
obj.notifyAll()是从obj的wait set中唤醒所有线程；

注意：线程必须有欲调用的实例的锁定，才能执行上述三个方法（这个规则）。