Java学习笔记（多线程_1）

15 多线程

15.1 概念

进程：正在进行中的程序；每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：进程中负责程序执行的控制单元（执行路径），线程在控制着进程的执行。

一个进程中至少有一个线程；

一个进程中可以由多个执行路径，称为多线程；

开启多线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

15.2 创建线程的方法

15.2.1 方法一：继承Thread类

通过对api的查找，java已经提供了对线程这类事物的描述，即Thread类。

定义类继承Thread；

重写Thread类中的run方法；目的：将自定义的方法存储在线程中，让线程运行；

调用线程的start方法，该方法两个作用：启动线程和调用run方法；

例1

class Demo extends Thread{
public void run(){
for(int x =0;x<6;x++){
System.out.println("demo run"+x);
}
}
}
public class ThreadDemo {

public static void main(String[] args) {
Demo d = new Demo();//创建了一个线程
d.start();//开启线程并执行该线程的run方法
//d.run();//仅仅对象调用方法，而线程创建了并未运行。
for(int x =0;x<5;x++){
System.out.println("Hello"+x);
}
}

}

运行结果：


创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

为何要重写run方法：

Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

多线程运行状态：



例2

class Demo extends Thread{
Demo(String name){
super(name);
}

public void run(){
for(int x =0;x<6;x++){
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+".run.."+x);
}
}
}
public class ThreadDemo {

public static void main(String[] args) {
Demo d = new Demo("one");//创建了一个线程
Demo d1= new Demo("two");
d.start();
d1.start();

for(int x =0;x<5;x++){
System.out.println("Hello"+x);
}
}

}

PS：

1. 可通过Thread的getName()方法获取线程的名称，名称格式如下：Thread-编号（0开始）；

2. Thread创建时就已经命名了；

3. currentThread();获取当前线程对象；

4. 设置线程名称：setName或者构造函数。

15.2.2 方法二：实现Runnable接口

步骤：

定义类 Runnable接口；

重写Runnable接口中的run方法；将线程要运行的代码放在该run方法中；

通过Thread类建立线程对象；

将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数；

调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例3

class Ticket1 implements Runnable{
private int tick = 8;
public void run(){
while(true){
if(tick>0)
System.out.println(Thread.currentThread().getName()+
"...sale.."+tick--);
}
}
}

public class TicketDemo {

public static void main(String[] args) {
Ticket1 t = new Ticket1();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);

t1.start();
t2.start();
t3.start();
}
}

运行结果：


实现方式和继承方式的区别：

实现Runnable接口避免了单继承的局限性，在定义线程时，建议使用实现方式；

继承Thread，线程代码存放在Thread子类run方法中；实现Runnable，线程代码存在接口的子类run方法中。

15.2.3 线程安全

代码：

class Ticket1 implements Runnable{
private int tick = 10;
public void run(){
while(true){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"...sale.."+tick--);
}
}
}
}

public class TicketDemo {

public static void main(String[] args) {
Ticket1 t = new Ticket1();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);

t1.start();
t2.start();
t3.start();
}
}

运行结果：


打印出tick小于等于0的结果，

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

采用同步代码块：

synchronized(对象){
需要被同步的代码；
}

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。

使用前提必须有多个线程并使用同一个锁。

修改后的代码：

class Ticket1 implements Runnable{
private int tick = 10;
Object obj = new Object();
public void run(){
while(true){
synchronized(obj){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"...sale.."+tick--);
}
}
}
}
}

public class TicketDemo {

public static void main(String[] args) {
Ticket1 t = new Ticket1();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);

t1.start();
t2.start();
t3.start();
}
}

同步代码块的弊端：多个线程需要判断锁，较为消耗资源，会降低程

序的运行效率。

如何找问题：

明确哪些代码是多线程运行代码；

明确共享数据；

明确多线程运行代码中哪些语句是操作共享数据的。

例4：

class Bank{
private int sum;
public void add(int n){
sum += n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sum="+sum);
}
}

class Cus implements Runnable{
private Bank b = new Bank();

public void run() {
for(int x=0;x<3;x++){
b.add(100);
}
}
}

public class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
Thread t3 = new Thread(c);
t1.start();
t2.start();
t3.start();
}
}

运行结果：


修改后：

class Bank{
private int sum;
Object obj = new Object();
public synchronized void add(int n){//同步函数
//synchronized(obj){
sum += n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sum="+sum);
//}
}
}

class Cus implements Runnable{
private Bank b = new Bank();

public void run() {
for(int x=0;x<3;x++){
b.add(100);
}
}
}

public class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
Thread t3 = new Thread(c);
t1.start();
t2.start();
t3.start();
}
}

同步的两种表现形式：同步代码块和同步函数。

Ps:

1. 同步函数的锁是固定的this；

2. 同步代码块的锁是任意的对象。

由于同步函数的锁是固定的this，同步代码块是锁的任意的对象，如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

class Ticket implements Runnable{
private int tick = 10;
boolean flag = true;

//Object obj = new Object();
public void run(){
if(flag){
while(true){
synchronized(this){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"...code.."+tick--);
}
}
}
}else{
while(true)
show();
}
}

public synchronized void show(){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"..function.."+tick--);
}
}
}

public class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);

t1.start();
try {
Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag=false;
t2.start();
}
}

运行结果：


如果同步函数被静态修饰后，使用的锁不是this，而是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

class Ticket implements Runnable{
private static int tick = 10;
boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(Ticket.class){//this.getClass()
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"...code.."+tick--);
}
}
}
}else{
while(true)
show();
}
}

public static synchronized void show(){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"..function.."+tick--);
}
}
}

public class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);

t1.start();
try {
Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag=false;
t2.start();
}
}

15.2.4 多线程中单例模式

1. 饿汉式

class Single{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}

饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况。

2. 懒汉式

class Single{
private static Single s = null;
private Single(){}

public static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null)
s =new Single();
}
}
return s;
}
}

懒汉式存在安全问题，可以使用同步函数解决。

方式一：

public static synchronized Single getInstance(){
if(s==null)
s =new Single();
return s;
}

该方式使用效率较低，每次均需要判断；

方法二：

public static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null)
s =new Single();
}
}
return s;
}

原因在于任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则

再判断是否能够获取锁。

对于单例而言，只有一个对象，因此如果对象已经创建则可直接获取；

如果没有对象，则进行判断获取锁，

如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。

如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。

15.2.5 死锁

同步嵌套的死锁

class Ticket implements Runnable{

private static int tick = 10;

boolean flag = true;

Object obj = new Object();

public void run(){
if(flag){
while(true){
synchronized(obj){//this.getClass()
show();
}
}
}else{
while(true)
show();
}
}

public synchronized void show(){
synchronized(obj){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"..function.."+tick--);
}
}
}
}

public class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);

t1.start();
try {
Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
} catch (InterruptedException e) {
e.printStackTrace();
}
t.flag=false;
t2.start();
}
}