C#多线程及同步示例简析

60年代,在OS中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程出现了很多弊端,一是由于进程是资源拥有者,创建、撤消与切换存在较大的时空开销,因此需要引入轻型进程;二是由于对称多处理机(SMP)出现,可以满足多个运行单位,而多个进程并行开销过大。
因此在80年代,出现了能独立运行的基本单位——线程(Threads)。
       线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。另外,线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件,逻辑上可以运行,在等待处理机;运行状态是指线程占有处理机正在运行;阻塞状态是指线程在等待一个事件(如某个信号量),逻辑上不可执行。每一个程序都至少有一个线程,若程序只有一个线程,那就是程序本身。
       线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元,是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作,称为多线程。

一、线程简义

1、进程与线程:进程作为操作系统执行程序的基本单位,拥有应用程序的资源,进程包含线程,进程的资源被线程共享,线程不拥有资源。

2、前台线程和后台线程:通过Thread类新建线程默认为前台线程。当所有前台线程关闭时,所有的后台线程也会被直接终止,不会抛出异常。

3、挂起(Suspend)和唤醒(Resume):由于线程的执行顺序和程序的执行情况不可预知,所以使用挂起和唤醒容易发生死锁的情况,在实际应用中应该尽量少用。

4、阻塞线程:Join,阻塞调用线程,直到该线程终止。

5、终止线程:Abort:抛出 ThreadAbortException 异常让线程终止,终止后的线程不可唤醒。Interrupt:抛出 ThreadInterruptException 异常让线程终止,通过捕获异常可以继续执行。

6、线程优先级:AboveNormal BelowNormal Highest Lowest Normal,默认为Normal。

二、线程的使用

线程函数通过委托传递,可以不带参数,也可以带参数(只能有一个参数),可以用一个类或结构体封装参数。

namespace Test
{
  class Program
  {
    static void Main(string[] args)
    {
      Thread t1 = new Thread(new ThreadStart(TestMethod));
      Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
      t1.IsBackground = true;
      t2.IsBackground = true;
      t1.Start();
      t2.Start("hello");
      Console.ReadKey();
    }

    public static void TestMethod()
    {
      Console.WriteLine("不带参数的线程函数");
    }

    public static void TestMethod(object data)
    {
      string datastr = data as string;
      Console.WriteLine("带参数的线程函数,参数为:{0}", datastr);
    }
  }
}

三、线程池

由于线程的创建和销毁需要耗费一定的开销,过多的使用线程会造成内存资源的浪费,出于对性能的考虑,于是引入了线程池的概念。线程池维护一个请求队列,线程池的代码从队列提取任务,然后委派给线程池的一个线程执行,线程执行完不会被立即销毁,这样既可以在后台执行任务,又可以减少线程创建和销毁所带来的开销。

线程池线程默认为后台线程(IsBackground)。

class Program
  {
    static void Main(string[] args)
    {
      //将工作项加入到线程池队列中,这里可以传递一个线程参数
      ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
      Console.ReadKey();
    }

    public static void TestMethod(object data)
    {
      string datastr = data as string;
      Console.WriteLine(datastr);
    }
  }

四、Task类

使用ThreadPool的QueueUserWorkItem()方法发起一次异步的线程执行很简单,但是该方法最大的问题是没有一个内建的机制让你知道操作什么时候完成,有没有一个内建的机制在操作完成后获得一个返回值。为此,可以使用System.Threading.Tasks中的Task类。

构造一个Task<TResult>对象,并为泛型TResult参数传递一个操作的返回类型。

class Program
  {
    static void Main(string[] args)
    {
      Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
      t.Start();
      t.Wait();
      Console.WriteLine(t.Result);
      Console.ReadKey();
    }

    private static Int32 Sum(Int32 n)
    {
      Int32 sum = 0;
      for (; n > 0; --n)
        checked{ sum += n;} //结果太大,抛出异常
      return sum;
    }
  }

一个任务完成时,自动启动一个新任务。

一个任务完成后,它可以启动另一个任务,下面重写了前面的代码,不阻塞任何线程。

class Program
  {
    static void Main(string[] args)
    {
      Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
      t.Start();
      //t.Wait();
      Task cwt = t.ContinueWith(task => Console.WriteLine("The result is {0}",t.Result));
      Console.ReadKey();
    }

    private static Int32 Sum(Int32 n)
    {
      Int32 sum = 0;
      for (; n > 0; --n)
        checked{ sum += n;} //结果溢出,抛出异常
      return sum;
    }
  }

五、委托异步执行

委托的异步调用:BeginInvoke() 和 EndInvoke()

public delegate string MyDelegate(object data);
  class Program
  {
    static void Main(string[] args)
    {
      MyDelegate mydelegate = new MyDelegate(TestMethod);
      IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");

      //异步执行完成
      string resultstr = mydelegate.EndInvoke(result);
    }

    //线程函数
    public static string TestMethod(object data)
    {
      string datastr = data as string;
      return datastr;
    }

    //异步回调函数
    public static void TestCallback(IAsyncResult data)
    {
      Console.WriteLine(data.AsyncState);
    }
  }

六、线程同步

1)原子操作(Interlocked):帮助保护免受计划程序切换上下文时某个线程正在更新可以由其他线程访问的变量或者在单独的处理器上同时执行两个线程就可能出现的错误。 此类的成员不会引发异常。

class Program
  {
    static int counter = 1;

    static void Main(string[] args)
    {
      Thread t1 = new Thread(new ThreadStart(F1));
      Thread t2 = new Thread(new ThreadStart(F2));

      t1.Start();
      t2.Start();

      t1.Join();
      t2.Join();

      System.Console.ReadKey();
    }

    static void F1()
    {
      for (int i = 0; i < 5; i++)
      {
        Interlocked.Increment(ref counter);
        System.Console.WriteLine("Counter++ {0}", counter);
        Thread.Sleep(10);
      }
    }

    static void F2()
    {
      for (int i = 0; i < 5; i++)
      {
        Interlocked.Decrement(ref counter);
        System.Console.WriteLine("Counter-- {0}", counter);
        Thread.Sleep(10);
      }
    }
  }

2)lock()语句:避免锁定public类型,否则实例将超出代码控制的范围,定义private对象来锁定。而自定义类推荐用私有的只读静态对象,比如:private static readonly object obj = new object();为什么要设置成只读的呢?这时因为如果在lock代码段中改变obj的值,其它线程就畅通无阻了,因为互斥锁的对象变了,object.ReferenceEquals必然返回false。Array 类型提供 SyncRoot。许多集合类型也提供 SyncRoot。

3)Monitor实现线程同步

通过Monitor.Enter() 和 Monitor.Exit()实现排它锁的获取和释放,获取之后独占资源,不允许其他线程访问。

还有一个TryEnter方法,请求不到资源时不会阻塞等待,可以设置超时时间,获取不到直接返回false。

public void MonitorSomeThing()
    {
      try
      {
        Monitor.Enter(obj);
        dosomething();
      }
      catch(Exception ex)
      {

      }
      finally
      {
        Monitor.Exit(obj);
      }
    }

4)ReaderWriterLock

当对资源操作读多写少的时候,为了提高资源的利用率,让读操作锁为共享锁,多个线程可以并发读取资源,而写操作为独占锁,只允许一个线程操作。

class SynchronizedCache
  {
    private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
    private Dictionary<int, string> innerCache = new Dictionary<int, string>(); 

    public string Read(int key)
    {
      cacheLock.EnterReadLock();
      try
      {
        return innerCache[key];
      }
      finally
      {
        cacheLock.ExitReaderLock();
      }
    } 

    public void Add(int key, string value)
    {
      cacheLock.EnterWriteLock();
      try
      {
        innerCache.Add(key, value);
      }
      finally
      {
        cacheLock.ExitWriteLock();
      }
    } 

    public bool AddWithTimeout(int key, string value, int timeout)
    {
      if (cacheLock.TryEnterWriteLock(timeout))
      {
        try
        {
          innerCache.Add(key, value);
        }
        finally
        {
          cacheLock.ExitReaderLock();
        }
        return true;
      }
      else
      {
        return false;
      }
    } 

    public AddOrUpdateStatus AddOrUpdate(int key, string value)
    {
      cacheLock.EnterUpgradeableReadLock();
      try
      {
        string result = null;
        if (innerCache.TryGetValue(key, out result))
        {
          if (result == value)
          {
            return AddOrUpdateStatus.Unchanged;
          }
          else
          {
            cacheLock.EnterWriteLock();
            try
            {
              innerCache[key] = value;
            }
            finally
            {
              cacheLock.ExitWriteLock();
            }
            return AddOrUpdateStatus.Updated;
          }
        }
        else
        {
          cacheLock.EnterWriteLock();
          try
          {
            innerCache.Add(key, value);
          }
          finally
          {
            cacheLock.ExitWriteLock();
          }
          return AddOrUpdateStatus.Added;
        }
      }
      finally
      {
        cacheLock.ExitUpgradeableReadLock();
      }
    } 

    public void Delete(int key)
    {
      cacheLock.EnterWriteLock();
      try
      {
        innerCache.Remove(key);
      }
      finally
      {
        cacheLock.ExitWriteLock();
      }
    } 

    public enum AddOrUpdateStatus
    {
      Added,
      Updated,
      Unchanged
    };
  }

5)事件(Event)类实现同步

事件类有两种状态,终止状态和非终止状态,终止状态时调用WaitOne可以请求成功,通过Set将时间状态设置为终止状态。

 1).AutoResetEvent(自动重置事件)

 2).ManualResetEvent(手动重置事件)

AutoResetEvent和ManualResetEvent这两个类经常用到, 他们的用法很类似,但也有区别。Set方法将信号置为发送状态,Reset方法将信号置为不发送状态,WaitOne等待信号的发送。可以通过构造函数的参数值来决定其初始状态,若为true则非阻塞状态,为false为阻塞状态。如果某个线程调用WaitOne方法,则当信号处于发送状态时,该线程会得到信号, 继续向下执行。其区别就在调用后,AutoResetEvent.WaitOne()每次只允许一个线程进入,当某个线程得到信号后,AutoResetEvent会自动又将信号置为不发送状态,则其他调用WaitOne的线程只有继续等待.也就是说,AutoResetEvent一次只唤醒一个线程;而ManualResetEvent则可以唤醒多个线程,因为当某个线程调用了ManualResetEvent.Set()方法后,其他调用WaitOne的线程获得信号得以继续执行,而ManualResetEvent不会自动将信号置为不发送。也就是说,除非手工调用了ManualResetEvent.Reset()方法,则ManualResetEvent将一直保持有信号状态,ManualResetEvent也就可以同时唤醒多个线程继续执行。

6)信号量(Semaphore)

信号量是由内核对象维护的int变量,为0时,线程阻塞,大于0时解除阻塞,当一个信号量上的等待线程解除阻塞后,信号量计数+1。

线程通过WaitOne将信号量减1,通过Release将信号量加1,使用很简单。

public Thread thrd;
    //创建一个可授权2个许可证的信号量,且初始值为2
    static Semaphore sem = new Semaphore(2, 2);

    public mythread(string name)
    {
      thrd = new Thread(this.run);
      thrd.Name = name;
      thrd.Start();
    }
    void run()
    {
      Console.WriteLine(thrd.Name + "正在等待一个许可证……");
      //申请一个许可证
      sem.WaitOne();
      Console.WriteLine(thrd.Name + "申请到许可证……");
      for (int i = 0; i < 4 ; i++)
      {
        Console.WriteLine(thrd.Name + ": " + i);
        Thread.Sleep(1000);
      }
      Console.WriteLine(thrd.Name + " 释放许可证……");
      //释放
      sem.Release();
    }
  }

  class mysemaphore
  {
    public static void Main()
    {
      mythread mythrd1 = new mythread("Thrd #1");
      mythread mythrd2 = new mythread("Thrd #2");
      mythread mythrd3 = new mythread("Thrd #3");
      mythread mythrd4 = new mythread("Thrd #4");
      mythrd1.thrd.Join();
      mythrd2.thrd.Join();
      mythrd3.thrd.Join();
      mythrd4.thrd.Join();
    }
  }

7)互斥体(Mutex)

独占资源,可以把Mutex看作一个出租车,乘客看作线程。乘客首先等车,然后上车,最后下车。当一个乘客在车上时,其他乘客就只有等他下车以后才可以上车。而线程与C# Mutex对象的关系也正是如此,线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放,如果它等待的C# Mutex对象被释放了,它就自动拥有这个对象,直到它调用Mutex.ReleaseMutex()方法释放这个对象,而在此期间,其他想要获取这个C# Mutex对象的线程都只有等待。

class Test
  {
    /// <summary>
    /// 应用程序的主入口点。
    /// </summary>
    [STAThread]
    static void Main(string[] args)
    {
      bool flag = false;
      System.Threading.Mutex mutex = new System.Threading.Mutex(true, "Test", out flag);
      //第一个参数:true--给调用线程赋予互斥体的初始所属权
      //第一个参数:互斥体的名称
      //第三个参数:返回值,如果调用线程已被授予互斥体的初始所属权,则返回true
      if (flag)
      {
        Console.Write("Running");
      }
      else
      {
        Console.Write("Another is Running");
        System.Threading.Thread.Sleep(5000);//线程挂起5秒钟
        Environment.Exit(1);//退出程序
      }
      Console.ReadLine();
    }
  }

8)跨进程间的同步

通过设置同步对象的名称就可以实现系统级的同步,不同应用程序通过同步对象的名称识别不同同步对象。

static void Main(string[] args)
    {
      string MutexName = "InterProcessSyncName";
      Mutex SyncNamed;   //声明一个已命名的互斥对象
       try
      {
        SyncNamed = Mutex.OpenExisting(MutexName);    //如果此命名互斥对象已存在则请求打开
      }
      catch (WaitHandleCannotBeOpenedException)
      {
        SyncNamed = new Mutex(false, MutexName);     //如果初次运行没有已命名的互斥对象则创建一个
      }
      Task MulTesk = new Task
        (
          () =>         //多任务并行计算中的匿名方法,用委托也可以
          {
            for (; ; )     //为了效果明显而设计
            {
              Console.WriteLine("当前进程等待获取互斥访问权......");
              SyncNamed.WaitOne();
              Console.WriteLine("获取互斥访问权,访问资源完毕,按回车释放互斥资料访问权.");
              Console.ReadLine();
              SyncNamed.ReleaseMutex();
              Console.WriteLine("已释放互斥访问权。");
            }
          }
        );
      MulTesk.Start();
      MulTesk.Wait();
    }

9)分布式的同步

可以使用redis任务队列或者redis相关特性

Parallel.For(0, 1000000, i =>
 {
  Stopwatch sw1 = new Stopwatch();
   sw1.Start();

    if (redisHelper.GetRedisOperation().Lock(key))
       {
     var tt = int.Parse(redisHelper.GetRedisOperation().StringGet("calc"));

     tt++;

     redisHelper.GetRedisOperation().StringSet("calc", tt.ToString());

     redisHelper.GetRedisOperation().UnLock(key);
            }
            var v = sw1.ElapsedMilliseconds;
            if (v >= 10 * 1000)
            {
              Console.Write("f");
        }
      sw1.Stop();
 });

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 详解C#多线程之线程同步

    多线程内容大致分两部分,其一是异步操作,可通过专用,线程池,Task,Parallel,PLINQ等,而这里又涉及工作线程与IO线程:其二是线程同步问题,鄙人现在学习与探究的是线程同步问题. 通过学习<CLR via C#>里面的内容,对线程同步形成了脉络较清晰的体系结构,在多线程中实现线程同步的是线程同步构造,这个构造分两大类,一个是基元构造,一个是混合构造.所谓基元则是在代码中使用最简单的构造.基原构造又分成两类,一个是用户模式,另一个是内核模式.而混合构造则是在内部会使用基元构造的用户模

  • c#.net多线程编程教学——线程同步

    随着对多线程学习的深入,你可能觉得需要了解一些有关线程共享资源的问题. .NET framework提供了很多的类和数据类型来控制对共享资源的访问. 考虑一种我们经常遇到的情况:有一些全局变量和共享的类变量,我们需要从不同的线程来更新它们,可以通过使用System.Threading.Interlocked类完成这样的任务,它提供了原子的,非模块化的整数更新操作. 还有你可以使用System.Threading.Monitor类锁定对象的方法的一段代码,使其暂时不能被别的线程访问. System

  • 详细解析C#多线程同步事件及等待句柄

    最近捣鼓了一下多线程的同步问题,发现其实C#关于多线程同步事件处理还是很灵活,这里主要写一下,自己测试的一些代码,涉及到了AutoResetEvent 和 ManualResetEvent,当然还有也简要提了一下System.Threading.WaitHandle.WaitOne .System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ,下面我们一最初学者的角度来看,多线程之间的同步. 假设有这样的一个场

  • C#多线程编程之使用ReaderWriterLock类实现多用户读与单用户写同步的方法

    本文实例讲述了C#多线程编程之使用ReaderWriterLock类实现多用户读与单用户写同步的方法.分享给大家供大家参考,具体如下: 摘要:C#提供了System.Threading.ReaderWriterLock类以适应多用户读/单用户写的场景.该类可实现以下功能:如果资源未被写操作锁定,那么任何线程都可对该资源进行读操作锁定,并且对读操作锁数量没有限制,即多个线程可同时对该资源进行读操作锁定,以读取数据. 使用Monitor或Mutex进行同步控制的问题:由于独占访问模型不允许任何形式的

  • C#实现多线程的同步方法实例分析

    本文主要描述在C#中线程同步的方法.线程的基本概念网上资料也很多就不再赘述了.直接接入 主题,在多线程开发的应用中,线程同步是不可避免的.在.Net框架中,实现线程同步主要通过以下的几种方式来实现,在MSDN的线程指南中已经讲了几种,这里结合作者实际中用到的方式一起说明一下. 1. 维护自由锁(InterLocked)实现同步 2. 监视器(Monitor)和互斥锁(lock) 3. 读写锁(ReadWriteLock) 4. 系统内核对象 1) 互斥(Mutex), 信号量(Semaphore

  • C#简单多线程同步和优先权用法实例

    本文实例讲述了C#简单多线程同步和优先权用法.分享给大家供大家参考.具体分析如下: 本文实例题目如下: 麦当劳有两个做汉堡的厨师(工号:11,12)和三个销售人员(工号:21,22,23). 厨师生产汉堡,并负责将做好的汉堡放入货架,货架台大小有限,最多放6个汉堡,11和12不能同时往货架台上放汉堡,11具有优先权. 销售人员负责销售食品,三个销售人员取食品时,货架不能为空,三人不能同时取,23优先权最高,21最低.21卖的最快,取得频率最高,22次之. 一天的工作量是销售70个汉堡. 这里先来

  • C#多线程及同步示例简析

    60年代,在OS中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程出现了很多弊端,一是由于进程是资源拥有者,创建.撤消与切换存在较大的时空开销,因此需要引入轻型进程:二是由于对称多处理机(SMP)出现,可以满足多个运行单位,而多个进程并行开销过大. 因此在80年代,出现了能独立运行的基本单位--线程(Threads).        线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程ID,当前指令指针(P

  • 无感知刷新Token示例简析

    目录 引言 Token认证的原理 什么是无感知刷新Token 实现步骤 步骤一:获取Access Token和Refresh Token 步骤二:在请求中携带Access Token 步骤三:拦截401 Unauthorized响应 步骤四:服务器处理Refresh Token请求 步骤五:设置定时刷新Token 安全性考虑 引言 在前后端分离的应用中,使用Token进行认证是一种较为常见的方式.但是,由于Token的有效期限制,需要不断刷新Token,否则会导致用户认证失败.为了解决这个问题,

  • c#中多线程间的同步示例详解

    目录 一.引入 二.Lock 三.Monitor 四.Interlocked 五.Semaphore 六.Event 七.Barrier 八.ReaderWriterLockSlim 九.Mutex 十.ThreadLocal ,AsyncLocal,Volatile 十一.有意思的示例 总结 一.引入 先给出一个Num类的定义 internal class Num { public static int odd = 50000; public static int even = 10000;

  • shp2sqlserver 用法简析

    shp2sqlserver用法简析 官方说明: shp2sqlserver is a command line tool for loading shapefiles into Microsoft SQL Server 2008. It is modeled after PostGIS's shp2pgsql, except that it loads directly into the database instead of writing sql to stdout. http://code

  • Android多线程之同步锁的使用

    本文主要介绍了Android多线程之同步锁的使用,分享给大家,具体如下: 一.同步机制关键字synchronized 对于Java来说,最常用的同步机制就是synchronized关键字,他是一种基于语言的粗略锁,能够作用于对象.函数.class.每个对象都只有一个锁,谁能够拿到这个锁谁就有访问权限.当synchronized作用于函数时,实际上锁的也是对象,锁定的对象就是该函数所在类的对象.而synchronized作用于class时则是锁的这个Class类,并非具体对象. public cl

  • 简析Linux网络编程函数

    目录 1,创建套接字socket 2,绑定套接字bind 3,创建监听:listen 4,等待连接accept 5, 收发消息send和recv 6,关闭套接字描述符close 7,基于tcp协议的C/S服务器模型 8,实现代码 网络编程的一些基本函数:也是实现tcp协议通讯的基本步骤,实现代码在最后,IP需要修改为自己的IP,即可通信: 1,创建套接字socket 函数原型: #include<sys/types.h> #include<sys/socket.h> int soc

  • C++中关键字 override 的简析

    目录 在C++中,虚函数是最常见的实现多态的机制之一,来个最简单的例子温习一下: class Base // 基类 { public: virtual void f(){cout << "Base::f()" << endl;} }; ​ class Derived1 : public Base // 派生类1 { virtual void f(){cout << "Derived1::f()" << endl;} }

  • Java多线程之同步工具类CyclicBarrier

    目录 1 CyclicBarrier方法说明 2 CyclicBarrier实例 3 CyclicBarrier源码解析 CyclicBarrier构造函数 await方法 nextGeneration的源码 breakBarrier源码 isBroken方法 reset方法 getNumberWaiting方法 前言: CyclicBarrier是一个同步工具类,它允许一组线程互相等待,直到达到某个公共屏障点.与CountDownLatch不同的是该barrier在释放线程等待后可以重用,所以

  • iOS开发探索多线程GCD任务示例详解

    目录 引言 同步任务 死锁 异步任务 总结 引言 在上一篇文章中,我们探寻了队列是怎么创建的,串行队列和并发队列之间的区别,接下来我们在探寻一下GCD的另一个核心 - 任务 同步任务 void dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block); 我们先通过lldb查看其堆栈信息,分别查看其正常运行和死锁状态的信息 我们再通过源码查询其实现 #define _dispatch_Block_

  • iOS开发探索多线程GCD队列示例详解

    目录 引言 进程与线程 1.进程的定义 2.线程的定义 3. 进程和线程的关系 4. 多线程 5. 时间片 6. 线程池 GCD 1.任务 2.队列 3.死锁 总结 引言 在iOS开发过程中,绕不开网络请求.下载图片之类的耗时操作,这些操作放在主线程中处理会造成卡顿现象,所以我们都是放在子线程进行处理,处理完成后再返回到主线程进行展示. 多线程贯穿了我们整个的开发过程,iOS的多线程操作有NSThread.GCD.NSOperation,其中我们最常用的就是GCD. 进程与线程 在了解GCD之前

随机推荐