多线程

Java是一门支持多线程的编程语言！ 什么是进程？ 计算机中内存、处理器、IO等资源操作都要为进程进行服务。 一个进程上可以创建多个线程，线程比进程更快的处理单元，而且所占用的资源也小，多线程的应用也是性能最高的。 Java的多线程实现：（三种方式） 　　在Java中实现多线程有两种途径： 　　　　1、继承Thread类 　　　　2、实现Runnable接口 　　　　3、实现Callable接口 继承Thread类： class MyThread extends Thread { //继承Thread 即 多线程类【线程操作主类】 } ps：在Java中，任何一个类继承了Thread类，都视为该类为多线程类。 在Java程序中都有一个“起点”即开始的地方；那么多线程类也有一个“起点”—— run()方法 ，也就是说在多线程的每个主体类中都必须要覆写Thread类中所提供的 run() 方法 public void run() ; run()方法没有提供参数和返回值，那么也就表示了线程一旦开始就要一直执行，不能够返回内容。 import sun.security.mscapi.KeyStore.MY; class MyThread extends Thread { //继承Thread 即 多线程类 private String name ; public MyThread

Java 多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如： public class MyThread extends Thread { 　　 public void run() { 　　 System.out.println( "MyThread.run()"); 　　} } public class MyThread extends Thread { 　　public void run() { 　　 System.out.println("MyThread.run()"); 　　} } 在合适的地方启动线程如下： MyThread

最近在写一个TCP通信程序，自定义了一个通信类TCPclient，用于客户端异步接收和发送网络消息。 TCPclient中定义了一个接收到新的网络消息事件： 1 //收到新消息事件 2 public delegate void receiveNewNetworkMsgHandler( string networkMSG); 3 public event receiveNewNetworkMsgHandler receiveNewNetworkMsg; 在外部的窗体中订阅了此事件： void thisClient_receiveNewNetworkMsg( string networkMSG); 起初是直接在这个函数中读取网络消息 ，并解析命令，然后触发窗体的LoginSuccess事件，LoginSuccess事件的委托函数会New一个 main 窗体 但是问题是这个new的main窗体总是无响应。 经过很长时间的摸索，终于得出以下结论 在自定义类中定义并触发事件，那么UI中的事件处理代码也就工作在自定义类线程中，访问UI中控件需要invoke 在此之前，我一直认为事件处理函数在哪个类，自然运行的时候就在相应的线程中执行，至此才明白错在哪里。 根据这条结论，自然就不能直接在thisClient

上篇和中篇讲解了什么是GCD，如何使用GCD，这篇文章将讲解使用GCD中将遇到的死锁问题。有兴趣的朋友可以回顾《 iOS多线程开发之GCD（上篇） 》和《 iOS多线程开发之GCD（中篇） 》。 言归正传，我们首先来回顾下死锁，所谓死锁: 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源（如数据源，内存等，变量不是资源）而造成的一种互相等待的现象，若无外部处理作用，它们都将无限等待下去。 　　死锁形成的原因： 系统资源不足 进程（线程）推进的顺序不恰当； 资源分配不当 　　死锁形成的条件： 互斥条件： 所谓互斥就是进程在某一时间内独占资源。 请求与保持条件： 一个进程因请求资源而阻塞时，对已获得的资源保持不放。 不剥夺条件： 进程已获得资源，在末使用完之前，不能强行剥夺。 循环等待条件： 若干进程之间形成一种头尾相接的循环等待资源关系。 在GCD中，主要的死锁就是当前串行队列里面同步执行当前串行队列。解决的方法就是将同步的串行队列放到另外一个线程执行。 在举例说明之前，我们先来回顾下GCD的中的任务派发和队列。 （1）任务派发 任务派发方式 说明 dispatch_sync() 同步执行，完成了它预定的任务后才返回，阻塞当前线程 dispatch_async() 异步执行，会立即返回，预定的任务会完成但不会等它完成，不阻塞当前线程 （2）队列种类 队列种类 说明 串行队列

　　线程的概述　　 线程是一个在进程基础上发展起来的概念，引入它是为了提高系统的并发执行程度，进一步减少时间和空间的开销。 一、线程不能独立存在，必须存在于某个进程中。 二、同一进程内的线程都可以访问进程的所有资源，因此线程之间的通信比进程之间的通信要方便得多。 三、同一进程内的线程切换也比进程方便。 四、线程必须被系统调度而获得CPU使用权后才能运行，所以线程的执行顺序不是由程序本身控制的，而是由系统调度决定的。 　　线程的创建方式　　 一、继承Thread类并重写run()方法。 class Pig extends Thread { public Pig(String threadName) { super(threadName); } public void run() { System.out.println("执行线程代码"); } public static void main(String[] args) { Pig pig1 = new Pig("线程1"); Pig pig2 = new Pig("线程2"); pig1.start(); pig2.start(); System.out.println("当前线程的线程组中活动线程的数目："+pig1.activeCount()); } } 二、实现Runnable接口并实现run()方法。 class Pig

一、线程的基本概念：　　　　　　　　　　　　　　　　　　　　　　　　 线程是一个程序里面不同的执行路径。 程序里面不同的执行路径，每一个分支都是一个线程。 进程：静态的概念。机器上的一个class文件，机器上的一个exe文件，这叫一个进程。 机器里面实际上运行的都是线程。 window等。linux等都是多进程，多线程的系统。 CPU的执行是这样的： CPU速度比较快，一秒钟算好几亿次，它把自己的时间分成一个一个的小时间片，这个时间片我执行你一会，再执行他一会，虽然有几十个线程， 没关系，执行这个一会，执行那个一会，挨着排的都执行一遍，但是对我们人来说，因为它速度太快了，你看起来就好像好多线程在同时执行一样。 但实际上，在一个时间点上， 这个CPU只有一个线程在运行。 如果机器是双CPU，或者是双核，那么确实是多线程。 二、线程的启动和创建：　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 例子1：实现Runnable接口： package com.cy.thread; public class TestThread1 { public static void main(String[] args) { Runner1 r = new Runner1(); Thread t = new Thread(r); //启动一个线程

并发：交替处理多个任务的能力 并行：同时处理多个任务的能力 1. GIL 全局解释器锁 作用：保证同一时刻只有一个线程使用cpu 效果：一个进程中只有一个gil，多个线程需要去抢夺GIl，没有办法真正的使用多个cpu。 注意：GIL存在于cpyhton解释器中的 多线程使用情况： 1 科学计算 单线程比较快 2 i/o操作 多线程比较快 2. 深拷贝和浅拷贝 copy.copy（）浅拷贝 copy.deepcopy（）深拷贝 在拷贝简单的数据类型 （a = [1,2]） 的时候没有区别 都是开辟新的一片空间存储数据 拷贝有嵌套的数据类型 浅拷贝 仅仅是拷贝了引用 没有办法保证数据的独立性 深拷贝 完全拷贝数据 并且开辟空间 保证数据的独立性 拷贝元组（不可变类型的数据）的时候 深拷贝和浅拷贝是一样的 不开辟新的空间 直接引用 如果不可变类型 比如元组中 有可变类型的数据 深拷贝：保证数据的独立性 浅拷贝：直接引用 切片拷贝，字典拷贝都是浅拷贝 3. 私有化 私有属性是通过 名字重整 进行保护的 01 父类中属性名为__名字的，子类不继承，子类不能访问 02 如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性 03 _名的变量、函数、类在使用from xxx import *时都不会被导入 4.import搜索路径：sys.path 模块重写后，需要重新导入

一、threading 　　多任务可以由多进程完成，也可以由一个进程内的多线程完成。我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。 　　Python的标准库提供了两个模块： thread 和 threading ， thread 是低级模块， threading 是高级模块，对 thread 进行了封装。绝大多数情况下，我们只需要使用 threading 这个高级模块。启动一个线程就是把一个函数传入并创建 Thread 实例，然后调用 start() 开始执行： import time, threading # 新线程执行的代码: def loop(): print 'thread %s is running...' % threading.current_thread().name n = 0 while n < 5: n = n + 1 print 'thread %s >>> %s' % (threading.current_thread().name, n) time.sleep(1) print 'thread %s ended.' % threading.current

多线程 多任务可以由多进程完成，也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。 由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外， 并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。 Python的标准库提供了两个模块： _thread 和 threading ， _thread 是低级模块， threading 是高级模块，对 _thread 进行了封装 。绝大多数情况下，我们只需要使用 threading 这个高级模块。 启动一个线程就是把一个函数传入并创建 Thread 实例，然后调用 start() 开始执行： import time, threading # 新线程执行的代码: def loop(): print('thread %s is running...' % threading.current_thread().name) n = 0 while n < 5: n = n + 1 print('thread %s >>> %s' % (threading.current_thread().name, n)) time.sleep(1) print('thread %s ended.' % threading.current_thread

多任务可以由多进程完成，也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。 由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。 Python的标准库提供了两个模块： _thread 和 threading ， _thread 是低级模块， threading 是高级模块，对 _thread 进行了封装。绝大多数情况下，我们只需要使用 threading 这个高级模块。 启动一个线程就是把一个函数传入并创建 Thread 实例，然后调用 start() 开始执行： import time, threading # 新线程执行的代码: def loop(): print('thread %s is running...' % threading.current_thread().name) n = 0 while n < 5: n = n + 1 print('thread %s >>> %s' % (threading.current_thread().name, n)) time.sleep(1) print('thread %s ended.' % threading.current_thread()