多线程下提交spark任务 多线程完成任务

1. 多任务

在计算机中，操作系统可以同时运行多个任务,这就是多任务。那么如何解决多个任务同时运行呢，那就需要用到多线程。多任务可以通过并发和并行来完成，那么什么是并发和并行呢？

• 并发：指的是任务数多于cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已），在实际开发中，并发是最常用的。
• 并行：当任务数小于或者等于cpu核数时，每一个任务都有对应的cpu来处理执行，即任务真的是一起执行的。

2. 多任务的实现-多线程

实现多任务需要用到多线程，那么什么是线程呢？下面是对它的理解：

• 一个程序运行起来至少有一个进程，一个进程至少有一个线程
• 处理器cpu分配给线程，即cpu真正运行的是线程中的代码
• 分配cpu给线程时，是通过时间片轮训方式进行的
• 进程是操作系统分配程序执行资源的单位，而线程是进程的一个实体，是CPU调度和分配的单位。

实现多线程的2种方式：

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用，通过threading模块可以创建线程

2.1 引入threading线程模块

import    threading，time 

def    download_music():

'''模拟下载歌曲，需要5秒钟下载完成'''

    for    i    in    range(5):

     time.sleep(1)# 休眠1秒

    print("---正在下载歌曲%d---"% i)

def    main():

    # 创建线程对象t1 ,target: 指向新开启的线程要执行的代码

    t1 = threading.Thread(target=download_music) 

    t1.start()# 启动线程，即线程开始执行

if__name__ =='__main__': 

     main()

2.2 继承Thread类，创建一个新的class，将要执行的代码 写到run函数里面

import    threading，time

# 自定义类，继承threading.Thread

class    MyThread(threading.Thread):

    def    run(self):

        for    i    in    range(5):

             time.sleep(1)

            # name属性中保存的是当前线程的名字

            msg ="I'm "+ self.name +' @ '+ str(i) 

             print(msg)

if__name__ =='__main__':

# 通过MyThread创建线程对象

    t1 = MyThread()

    # 开始执行线程

    t1.start()

3. 多线程的注意点

• 子线程何时开启，何时运行
  当调用thread.start()时 开启线程，再运行线程的代码
• 子线程何时结束
  子线程把target指向的函数中的语句执行完毕后，或者线程中的run函数代码执行完毕后，立即结束当前子线程
• 查看当前线程数量
  通过threading.enumerate()可枚举当前运行的所有线程
• 主线程何时结束
  所有子线程执行完毕后，主线程才结束
• 线程的执行顺序
  多线程的创建与执行都是无序的。
• 总结

• 每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
• 当线程的run()方法结束时该线程完成。
• 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

4. 共享全局变量

先来看一段代码：

from    threading    import    Thread

import    time

g_nums = [11,22,33]

def    main():

    def    work1(nums):

        nums.append(44) 

         print("----in work1---",nums)

    def    work2(nums):

        #延时一会，保证t1线程中的事情做完

        time.sleep(1) 

         print("----in work2---",nums)

if    __name__ == '__main__':

    t1 = Thread(target=work1, args=(g_nums,))

    t1.start()

    t2 = Thread(target=work2, args=(g_nums,))

    t2.start()

运行结果:

----inwork1--- [11,22,33,44]

----inwork2--- [11,22,33,44]

总结：

在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据

缺点就是，多线程对全局变量随意遂改可能造成全局变量的混乱（即线程非安全）

5. 多线程开发可能遇到的问题

假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算，t1和t2都各对g_num加10次，g_num的最终的结果应该为20。

但是由于是多线程同时操作，有可能出现下面情况：

    在g_num=0时，t1取得g_num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得g_num=0

    然后t2对得到的值进行加1并赋给g_num，使得g_num=1

    然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。

    这样导致虽然t1和t2都对g_num加1，但结果仍然是g_num=1。

所以，如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确，即会遇到线程安全问题

6. 使用同步机制解决线程安全问题-互斥锁

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

“同”字从字面上容易理解为一起动作，其实不是，”同”字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B执行，再将结果给A;A再继续操作。

在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的正确性。

互斥锁：

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

# 1.创建锁

mutex = threading.Lock()

#2. 锁定

mutex.acquire()

#3. 释放

mutex.release()

注意：

如果这个锁之前是没有上锁的，那么acquire不会堵塞

如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止

示例：使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import    threading，time

g_num =0

def    test1(num):

    global    g_num

    for    i    in    range(num):

        mutex.acquire()# 上锁

        g_num +=1

        mutex.release()# 解锁

    print("---test1---g_num=%d"%g_num)

def    test2(num):

    global    g_num

    for    i    in    range(num): 

        mutex.acquire()# 上锁

        g_num +=1

        mutex.release()# 解锁

    print("---test2---g_num=%d"%g_num)

# 创建一个互斥锁，默认是未上锁的状态

mutex = threading.Lock()

# 创建2个线程，让他们各自对g_num加1000000次

p1 = threading.Thread(target=test1, args=(1000000,))

p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))

p2.start()

# 等待计算完成

while    len(threading.enumerate()) !=1: 

     time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s"% g_num)

运行结果：

---test1---g_num=1909909

---test2---g_num=2000000

2个线程对同一个全局变量操作之后的最终结果是:2000000

可以看到最后的结果，加入互斥锁后，其结果与预期相符。

上锁解锁过程：

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。

每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。

线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

7. 死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子

import    threading ，time   

printer_mutex = threading.Lock()# 打印机锁

paper_mutext = threading.Lock()# 纸张锁

class    ResumeThread(threading.Thread):

"""编写个人简历任务的线程"""

    def    run(self):

        print("ResumeThread：编写个人简历任务")

        # 使用打印机资源，先对打印机加锁

        printer_mutex.acquire() 

         print("--ResumeThread：正在使用打印机资源--") 

         time.sleep(1)# 休眠1秒

        # 使用纸张耗材，先对纸张耗材加锁

        paper_mutext.acquire() 

        print("--正在使用纸张资源--") 

         time.sleep(1) 

         paper_mutext.release()# 释放纸张锁

        # 释放打印机锁

        printer_mutex.release()

class    PaperListThread(threading.Thread):

"""盘点纸张耗材任务的线程"""

    def    run(self):

        print("PaperListThread:盘点纸张耗材任务")

        # 使用纸张耗材，先对纸张耗材加锁

        paper_mutext.acquire() 

         print("--PaperListThread:正在盘点纸张耗材--")

         time.sleep(1)# 休眠1秒

        # 使用打印机资源，打印清单

        printer_mutex.acquire()

         print("--正在使用打印机资源--")

         time.sleep(1) 

         printer_mutex.release()# 释放打印机锁

        # 释放纸张耗材锁

        paper_mutext.release()

if__name__ =='__main__':

     t1 = ResumeThread()

     t2 = PaperListThread()

     t1.start() 

     t2.start()

从运行结果可以看出，两个线程都在等待对方释放资源，造成了死锁。

避免死锁的方式：

1.程序设计时要尽量避免

2.添加超时时间等