计算机的设计就是为了帮助人类或者模仿人类的某些行为。
生活中的多任务：人可以一边唱歌🎤一边跳舞💃、人开车的时候是通过手、脚和眼睛共同配合来驾驶一辆车🚗。
多任务编程就是这样一个鲜明的例子，计算机也可以实现多任务编程：比如一边听歌一边玩游戏、打开浏览器上网同时能登录微信、QQ等聊天工具。
那么Python的多任务有哪些方式呢？
Python多任务编程的三种方式

多线程
多进程
协程

今天我们先来聊一聊Python的多线程编程。
线程
有两种不同类型的线程：

内核线程
用户空间线程或用户线程

内核线程是操作系统的一部分，而用户空间线程未在内核中实现，关于线程和进程的更多概念请点此处
Python中的线程
Python中有两个关于线程的模块：

thread
threading

Ps：一直以来，thread模块一直都不被推荐使用，鼓励推荐使用threading模块，所以在Python3中的向后兼容，thread模块被重命名为_thread
>>> import thread
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    import thread
ModuleNotFoundError: No module named 'thread'
>>> import _thread
>>> 


threading 模块自 Python 1.5.1(1998 年)就已存在，不过有些人仍然继续使用旧的 thread 模块。Python 3 把 thread 模块重命名为 _thread，以此强调这是低层实现，不应该在应用代码中使用。

thread模块
可以使用Thread模块在单独的线程中执行功能。为此，我们可以使用函数thread.start_new_thread：
thread.start_new_thread(function, args[, kwargs])

此方法可以快速有效地在Linux和Windows中创建新线程。这个方法先接收一个函数对象（或其他可调用对象）和一个参数元组，然后开启新线程来执行所传入的函数对象及其传入的参数。
import _thread


def child(tid):
    print("Hello from thread", tid)


def parent():
    i = 0
    while True:
        i += 1
        _thread.start_new_thread(child, (i,))  # 创建线程的调用
            
        if input() == 'q':
            break
   
            
parent()

我们运行上段程序，然后只要不在控制台输入q，就能看到不断有新的线程创建和退出。当主线程退出时，整个线程就随之退出了。
Hello from thread 1

Hello from thread 2

Hello from thread 3

Hello from thread 4

Hello from thread 5
q

多线程唱歌跳舞
假如我们让电脑💻模拟唱跳，就需要启动两个线程，同时利用time.sleep避免主线程过早退出，但是线程输出可能随机。
from _thread import start_new_thread
import time


def sing():
    for i in range(3):
        print("I'm singing 难忘今宵")
        time.sleep(2)


def dance():
    for i in range(3):
        print("I'm dancing")
        time.sleep(2)


def main():
    start_new_thread(sing, ())
    start_new_thread(dance, ())
    time.sleep(8)
    print('Main thread exiting...')


if __name__ == '__main__':
    main()

如上代码，我们需要唱3遍“难忘今宵”，同时跳三遍伴舞。time.sleep(8)避免主线程过早退出导致新建的sing和dance线程提前退出，所以输出结果可能（每次执行的输出可能不一样）：
I'm singing 难忘今宵
I'm dancing
I'm dancing
I'm singing 难忘今宵
I'm dancing
I'm singing 难忘今宵
Main thread exiting...

输出结果的不规律是因为所有的线程的函数调用都在同一进程中运行，它们共享一个标准输出流，2个并行运行的线程输出都混杂在一起了。
更为重要的是，多个线程访问共享资源时，必须同步化访问以避免时间上的重叠。
我们为了防止主线程退出，整个程序终止，达不到自己想到的效果，利用了sleep()来作为同步机制，由于这个延时，整个程序的运行时间并没有比单线程的版本更快，而且多个线程一起共享某个变量/对象，那么就有可能会丢失其中一个。

我们看一下如下代码：
from _thread import start_new_thread
import time

num = 0


def plus_one():
    global num
    for i in range(1000):
        num += 1


def minus_one():
    global num
    for i in range(1000):
        num -= 1


def main():
    start_new_thread(plus_one, ())
    start_new_thread(minus_one, ())
    time.sleep(3)
    print(num)


if __name__ == '__main__':
    main()

我们共享一个全局变量num，启动两个线程：一个加一1000次，一个减一1000次，最后输出num的值，好像为0，但是果真如此吗？我们是一下循环100000次看看，
from _thread import start_new_thread
import time

num = 0


def plus_one():
    global num
    for i in range(100000):
        num += 1


def minus_one():
    global num
    for i in range(100000):
        num -= 1


def main():
    start_new_thread(plus_one, ())
    start_new_thread(minus_one, ())
    time.sleep(3)
    print(num)


if __name__ == '__main__':
    main()

输出num结果可能为整数，也可能为负数，也可能为0，这是因为线程执行顺序其实是随机的。
锁的概念
正因为存在上述的问题，所以引出锁的概念：想要修改一个共享对象，线程需要获得一把锁，然后进行修改，之后释放这把锁，然后才能被其他线程获取。通过allocate_lock()创建一个锁的对象，例如：
from _thread import start_new_thread, allocate_lock
import time

num = 0
mutex = allocate_lock()  # 增加一把锁


def plus_one():
    global num
    mutex.acquire()  # 获得锁

    for i in range(1000000):
        num += 1
    mutex.release()  # 释放锁


def minus_one():
    global num
    mutex.acquire()  # 获得锁
    for i in range(1000000):
        num -= 1
    mutex.release()  # 释放锁


def main():
    start_new_thread(plus_one, ())
    start_new_thread(minus_one, ())
    time.sleep(3)
    print(num)


if __name__ == '__main__':
    main()

这样执行后结果就会一直是0。
threading模块
threading是基于对象和类的较高层面上的接口，
threading.Thread((target=function_name, args=(function_parameter1, function_parameterN))

我们也首先实现一个上述加一减一的操作。
import threading

num = 0


def plus_one():
    global num

    for i in range(1000000):
        num += 1


def minus_one():
    global num
    for i in range(1000000):
        num -= 1


def main():
    t1 = threading.Thread(target=plus_one)
    t2 = threading.Thread(target=minus_one)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(num)

if __name__ == '__main__':
    main()

上锁
import threading

num = 0
mutex = threading.Lock()


def plus_one():
    global num
    mutex.acquire()
    for i in range(1000000):
        num += 1
    mutex.release()


def minus_one():
    global num
    mutex.acquire()
    for i in range(1000000):
        num -= 1
    mutex.release()


def main():
    t1 = threading.Thread(target=plus_one)
    t2 = threading.Thread(target=minus_one)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    
    print(num)


if __name__ == '__main__':
    main()

到此，我们简单的介绍了Python中两个关于线程的模块，然后通过共享变量引出锁的概念，不过到此并没有结束。比如：自定义线程、守护线程、死锁…

推荐阅读：

An Intro to Threading in Python
Multithreading in Python | Set 2(Synchronization)
Multithreading in Python | Set 1

前言
2020年过去了，很久之前就希望自己可以潜心研究源码，研究技术，但是空闲时间不是看电影，就是玩游戏都没有认真看技术方面的东西感觉很内疚，今年一定要好好的研究端正态度，认真学习技术。
Android面试中有哪些常见问题汇总&答题思路
目录：
1.网络

2.Java 基础&容器&同步&设计模式

3.Java 虚拟机&内存结构&GC&类加载&四种引用&动态代理

4.Android 基础&性能优化&Framwork

5.Android 模块化&热修复&热更新&打包&混淆&压缩

6.音视频&FFmpeg&播放器
1、网络
网络协议模型
应用层：负责处理特定的应用程序细节

HTTP、FTP、DNS
传输层：为两台主机提供端到端的基础通信

TCP、UDP
网络层：控制分组传输、路由选择等

IP
链路层：操作系统设备驱动程序、网卡相关接口
TCP 和 UDP 区别
TCP 连接；可靠；有序；面向字节流；速度慢；较重量；全双工；适用于文件传输、浏览器等

全双工：A 给 B 发消息的同时，B 也能给 A 发
半双工：A 给 B 发消息的同时，B 不能给 A 发

UDP 无连接；不可靠；无序；面向报文；速度快；轻量；适用于即时通讯、视频通话等
TCP 三次握手
A：你能听到吗？

B：我能听到，你能听到吗？

A：我能听到，开始吧
A 和 B 两方都要能确保：我说的话，你能听到；你说的话，我能听到。所以需要三次握手
TCP 四次挥手
A：我说完了

B：我知道了，等一下，我可能还没说完

B：我也说完了

A：我知道了，结束吧
B 收到 A 结束的消息后 B 可能还没说完，没法立即回复结束标示，只能等说完后再告诉 A ：我说完了。
POST 和 GET 区别
Get 参数放在 url 中；Post 参数放在 request Body 中

Get 可能不安全，因为参数放在 url 中
HTTPS
HTTP 是超文本传输协议，明文传输；HTTPS 使用 SSL 协议对 HTTP 传输数据进行了加密
HTTP 默认 80 端口；HTTPS 默认 443 端口
优点：安全

缺点：费时、SSL 证书收费，加密能力还是有限的，但是比 HTTP 强多了
2、Java 基础&容器&同步&设计模式
StringBuilder、StringBuffer、+、String.concat 链接字符串：

StringBuffer 线程安全，StringBuilder 线程不安全
+实际上是用 StringBuilder 来实现的，所以非循环体可以直接用 +，循环体不行，因为会频繁创建 StringBuilder
String.concat 实质是 new String ，效率也低，耗时排序：StringBuilder < StringBuffer < concat < +

Java 泛型擦除

修饰成员变量等类结构相关的泛型不会被擦除
容器类泛型会被擦除

ArrayList、LinkedList
ArrayList
基于数组实现，查找快：o(1)，增删慢：o(n)

初始容量为10，扩容通过 System.arrayCopy 方法
LinkedList
基于双向链表实现，查找慢：o(n)，增删快：o(1)

封装了队列和栈的调用
HashMap 、HashTable
HashMap

基于数组和链表实现，数组是 HashMap 的主体；链表是为解决哈希冲突而存在的
当发生哈希冲突且链表 size 大于阈值时会扩容，JAVA 8 会将链表转为红黑树提高性能

允许 key/value 为 null

HashTable

数据结构和 HashMap 一样
不允许 value 为 null
线程安全

ArrayMap、SparseArray
ArrayMap
1.基于两个数组实现，一个存放 hash；一个存放键值对。扩容的时候只需要数组拷贝，不需要重建哈希表

2.内存利用率高

3.不适合存大量数据，因为会对 key 进行二分法查找（1000以下）
SparseArray
1.基于两个数组实现，int 做 key

2.内存利用率高

3.不适合存大量数据，因为会对 key 进行二分法查找（1000以下）
volatile 关键字

只能用来修饰变量，适用修饰可能被多线程同时访问的变量
相当于轻量级的 synchronized，volatitle 能保证有序性（禁用指令重排序）、可见性；后者还能保证原子性
变量位于主内存中，每个线程还有自己的工作内存，变量在自己线程的工作内存中有份拷贝，线程直接操作的是这个拷贝
被 volatile 修饰的变量改变后会立即同步到主内存，保持变量的可见性。

双重检查单例，为什么要加 volatile？
1.volatile想要解决的问题是，在另一个线程中想要使用instance，发现instance!=null，但是实际上instance还未初始化完毕这个问题
2.将instance =newInstance();拆分为3句话是。1.分配内存2.初始化3.将instance指向分配的内存空
3.volatile可以禁止指令重排序，确保先执行2，后执行3
wait 和 sleep

sleep 是 Thread 的静态方法，可以在任何地方调用
wait 是 Object 的成员方法，只能在 synchronized 代码块中调用，否则会报 IllegalMonitorStateException 非法监控状态异常
sleep 不会释放共享资源锁，wait 会释放共享资源锁

lock 和 synchronized

synchronized 是 Java 关键字，内置特性；Lock 是一个接口
synchronized 会自动释放锁；lock 需要手动释放，所以需要写到 try catch 块中并在 finally 中释放锁
synchronized 无法中断等待锁；lock 可以中断
Lock 可以提高多个线程进行读/写操作的效率
竞争资源激烈时，lock 的性能会明显的优于 synchronized

可重入锁

定义：已经获取到锁后，再次调用同步代码块/尝试获取锁时不必重新去申请锁，可以直接执行相关代码
ReentrantLock 和 synchronized 都是可重入锁

公平锁

定义：等待时间最久的线程会优先获得锁
非公平锁无法保证哪个线程获取到锁，synchronized 就是非公平锁
ReentrantLock 默认时非公平锁，可以设置为公平锁

乐观锁和悲观锁

悲观锁：线程一旦得到锁，其他线程就挂起等待，适用于写入操作频繁的场景；synchronized 就是悲观锁
乐观锁：假设没有冲突，不加锁，更新数据时判断该数据是否过期，过期的话则不进行数据更新，适用于读取操作频繁的场景
乐观锁 CAS：Compare And Swap，更新数据时先比较原值是否相等，不相等则表示数据过去，不进行数据更新
乐观锁实现：AtomicInteger、AtomicLong、AtomicBoolean

死锁 4 个必要条件

互斥
占有且等待
不可抢占
循环等待

synchronized 原理

每个对象都有一个监视器锁：monitor，同步代码块会执行 monitorenter 开始，motnitorexit 结束
wait/notify 就依赖 monitor 监视器，所以在非同步代码块中执行会报 IllegalMonitorStateException 异常

3、Java 虚拟机&内存结构&GC&类加载&四种引用&动态代理
JVM

定义：可以理解成一个虚构的计算机，解释自己的字节码指令集映射到本地 CPU 或 OS 的指令集，上层只需关注 Class 文件，与操作系统无关，实现跨平台
Kotlin 就是能解释成 Class 文件，所以可以跑在 JVM 上

JVM 内存模型

Java 多线程之间是通过共享内存来通信的，每个线程都有自己的本地内存
共享变量存放于主内存中，线程会拷贝一份共享变量到本地内存
volatile 关键字就是给内存模型服务的，用来保证内存可见性和顺序性

JVM 内存结构
线程私有：
1.程序计数器：记录正在执行的字节码指令地址，若正在执行 Native 方法则为空

2.虚拟机栈：执行方法时把方法所需数据存为一个栈帧入栈，执行完后出栈

3.本地方法栈：同虚拟机栈，但是针对的是 Native 方法
线程共享：
1.堆：存储 Java 实例，GC 主要区域，分代收集 GC 方法会吧堆划分为新生代、老年代

2.方法区：存储类信息，常量池，静态变量等数据
GC
回收区域：只针对堆、方法区；线程私有区域数据会随线程结束销毁，不用回收
回收类型：
1.堆中的对象

分代收集 GC 方法会吧堆划分为新生代、老年代
新生代：新建小对象会进入新生代；通过复制算法回收对象
老年代：新建大对象及老对象会进入老年代；通过标记-清除算法回收对象

2.方法区中的类信息、常量池
判断一个对象是否可被回收：
1.引用计数法

缺点：循环引用
2.可达性分析法

定义：从 GC ROOT 开始搜索，不可达的对象都是可以被回收的
GC ROOT
1.虚拟机栈/本地方法栈中引用的对象

2.方法区中常量/静态变量引用的对象
四种引用

强引用：不会被回收
软引用：内存不足时会被回收
弱引用：gc 时会被回收
虚引用：无法通过虚引用得到对象，可以监听对象的回收

ClassLoader
类的生命周期：
1.加载；2.验证；3.准备；4.解析；5.初始化；6.使用；7.卸载
类加载过程：
1.加载：获取类的二进制字节流；生成方法区的运行时存储结构；在内存中生成 Class 对象

2.验证：确保该 Class 字节流符合虚拟机要求

3.准备：初始化静态变量

4.解析：将常量池的符号引用替换为直接引用

5.初始化：执行静态块代码、类变量赋值
类加载时机：
1.实例化对象

2.调用类的静态方法

3.调用类的静态变量（放入常量池的常量除外）
类加载器：负责加载 class 文件
分类：
1.引导类加载器 - 没有父类加载器

2.拓展类加载器 - 继承自引导类加载器

3.系统类加载器 - 继承自拓展类加载器
双亲委托模型：
当要加载一个 class 时，会先逐层向上让父加载器先加载，加载失败才会自己加载
为什么叫双亲？不考虑自定义加载器，系统类加载器需要网上询问两层，所以叫双亲
判断是否是同一个类时，除了类信息，还必须时同一个类加载器
优点：

防止重复加载，父加载器加载过了就没必要加载了
安全，防止篡改核心库类

动态代理原理及实现

InvocationHandler 接口，动态代理类需要实现这个接口
Proxy.newProxyInstance，用于动态创建代理对象
Retrofit 应用： Retrofit 通过动态代理，为我们定义的请求接口都生成一个动态代理对象，实现请求

4、Android 基础&性能优化&Framwork
Activity 启动模式

standard 标准模式
singleTop 栈顶复用模式，

推送点击消息界面


singleTask 栈内复用模式，

首页


singleInstance 单例模式，单独位于一个任务栈中

拨打电话界面

细节：
taskAffinity：任务相关性，用于指定任务栈名称，默认为应用包名
allowTaskReparenting：允许转移任务栈



View 工作原理

DecorView (FrameLayout)

LinearLayout

titlebar
Content
调用 setContentView 设置的 View





ViewRoot 的 performTraversals 方法调用触发开始 View 的绘制，然后会依次调用:

performMeasure：遍历 View 的 measure 测量尺寸
performLayout：遍历 View 的 layout 确定位置
performDraw：遍历 View 的 draw 绘制

事件分发机制

一个 MotionEvent 产生后，按 Activity -> Window -> decorView -> View 顺序传递，View 传递过程就是事件分发，主要依赖三个方法:
dispatchTouchEvent：用于分发事件，只要接受到点击事件就会被调用，返回结果表示是否消耗了当前事件
onInterceptTouchEvent：用于判断是否拦截事件，当 ViewGroup 确定要拦截事件后，该事件序列都不会再触发调用此 ViewGroup 的 onIntercept
onTouchEvent：用于处理事件，返回结果表示是否处理了当前事件，未处理则传递给父容器处理
细节：

一个事件序列只能被一个 View 拦截且消耗
View 没有 onIntercept 方法，直接调用 onTouchEvent 处理
OnTouchListener 优先级比 OnTouchEvent 高，onClickListener 优先级最低
requestDisallowInterceptTouchEvent 可以屏蔽父容器 onIntercet 方法的调用



Window 、 WindowManager、WMS、SurfaceFlinger

Window：抽象概念不是实际存在的，而是以 View 的形式存在，通过 PhoneWindow 实现
WindowManager：外界访问 Window 的入口，内部与 WMS 交互是个 IPC 过程
WMS：管理窗口 Surface 的布局和次序，作为系统级服务单独运行在一个进程
SurfaceFlinger：将 WMS 维护的窗口按一定次序混合后显示到屏幕上

View 动画、帧动画及属性动画
View 动画：

作用对象是 View，可用 xml 定义，建议 xml 实现比较易读
支持四种效果：平移、缩放、旋转、透明度

帧动画：

通过 AnimationDrawable 实现，容易 OOM

属性动画：

可作用于任何对象，可用 xml 定义，Android 3 引入，建议代码实现比较灵活
包括 ObjectAnimator、ValuetAnimator、AnimatorSet
时间插值器：根据时间流逝的百分比计算当前属性改变的百分比
系统预置匀速、加速、减速等插值器
类型估值器：根据当前属性改变的百分比计算改变后的属性值
系统预置整型、浮点、色值等类型估值器
使用注意事项：
避免使用帧动画，容易OOM
界面销毁时停止动画，避免内存泄漏
开启硬件加速，提高动画流畅性 ，硬件加速：
将 cpu 一部分工作分担给 gpu ，使用 gpu 完成绘制工作
从工作分摊和绘制机制两个方面优化了绘制速度

最后
上面这些公司都是时下最受欢迎的互联网大厂，他们的职级、薪资、福利也都讲的差不多了，相信大家都是有梦想和野心的人，心里多少应该都有些想法。
也相信很多人也都在为即将到来的金九银十做准备，也有不少人的目标都是这些公司。
我这边有不少朋友都在这些厂工作，其中也有很多人担任过面试官，上面的资料也差不多都是从朋友那边打探来的。除了上面的信息，我这边还有这些大厂近年来的面试真题及解析，以及一些朋友出于兴趣和热爱一起整理的Android时下热门知识点的学习资料。
点击这里加入我的圈子吧
以上都放在了我们的交流群里面，群共享文件还会不定时更新我们新的资料。群里有大厂的大牛也有普通码农，大家遇到问题都可以一起探讨交流，也可以潜水。
部分群文件：





十做准备，也有不少人的目标都是这些公司。
我这边有不少朋友都在这些厂工作，其中也有很多人担任过面试官，上面的资料也差不多都是从朋友那边打探来的。除了上面的信息，我这边还有这些大厂近年来的面试真题及解析，以及一些朋友出于兴趣和热爱一起整理的Android时下热门知识点的学习资料。
点击这里加入我的圈子吧
以上都放在了我们的交流群里面，群共享文件还会不定时更新我们新的资料。群里有大厂的大牛也有普通码农，大家遇到问题都可以一起探讨交流，也可以潜水。
部分群文件：

[外链图片转存中…(img-g14AX2EK-1623225848683)]

[外链图片转存中…(img-ujyk4U6E-1623225848686)]

关于游戏开发，需要对从一开始到最后开发一款游戏的一般过程有所了解。一般不是一个完整的，一步一步的指导完成的结果。你还需要自己找出相当多的东西才能有一个游戏。

第一步：选择游戏库

游戏库具有的功能：

一种加载和呈现图像的方法
	
一种加载和播放音频的方法
	
基本图像处理(旋转等)
	
原始绘图功能(圆、线、矩形、点等)
	
渲染文本的能力
	
跟踪时间和等待的能力
	
创建和控制线程的能力(但不是必需的)
第2步：定义概念——创意

所有的游戏都从这里开始，只是一个人头脑中的想法。

首先，想出一个游戏的主意。一旦你有一个简单的想法，扩展它。

例如，如果它是一个棋盘游戏，目标是什么/你如何赢？规则会是什么样子？等等，如果你的游戏中会有人物或故事，那就创造他们吧。确保你有一个相当明确的概念，你的游戏将是什么，当它结束。游戏越复杂，你就越应该在一开始就计划好，这样你就不用在编码的时候担心游戏本身了。记住，你的游戏会随着你的创造而进化。

第三步：规划你的引擎 

如果你正在制作一个棋盘游戏或者基本的街机游戏，你可以完全跳过这个游戏，只需对你的游戏进行编程。然而，对于更复杂的游戏，您可能需要考虑使用预先制作的引擎，或者编写自己的“引擎”。

游戏引擎到底是什么？虽然它们在结构和整体功能上差异很大，是提供更高级别功能(如物理、资源处理和游戏实体管理)的超级功能库。

选择使用存在引擎还是创建自己的引擎，这取决于您实际想要做多少编程。使用预先制作的引擎将简化您作为程序员的工作，编写游戏/事件脚本比其他任何事情都要简单。



为什么我要说计划而不是选择？嗯，很有可能你不会做下一个老卷轴，并因此，可以创造你自己的“引擎”的种类。请记住，您将不会创建下一个“虚幻引擎”，您编写并打算重用的大部分代码(正如引擎的要点一样)最终将与您的游戏逻辑交织在一起，因此不可能很容易地重用。考虑到这一点，不要担心如果你的“引擎”部分依赖于游戏的特定代码，这就会发生。不要专注于构建一个完全可重用、超级健壮的框架，而是要确保代码具有可读性、组织性和功能性。首先专注于制作游戏，然后尝试创建可移植模块。如果您一定要编写有用的、可重用的东西，那么资源管理器和其他各种实用程序类就是很好的起点。

步骤4：编写引擎(如果你是自己做的话）

现在是开始编写引擎的时候了，前提是这是您选择的路线。这不一定意味着游戏本身，而是核心渲染、物理和文件处理；本质上是用来构建游戏的函数和类。

简单的游戏并不需要太多的框架，只需直接使用游戏库编程即可。大型游戏中最重要、最被忽视的组件之一是资源管理器。资源管理器是一个类，它负责加载资源(考虑图形和声音)，确保只加载一次资源，并在不再需要资源时卸载资源。



引擎/框架的另一个重要方面是接口。当您编写游戏本身的逻辑时，编写主游戏循环不需要花4个小时，因为您搜索了数百个更新函数，试图找出您实际需要的函数。保持简洁。如果你能够用一个或两个函数调用来更新所有的游戏逻辑，然后再用一两个函数来渲染场景，那么你就在正确的轨道上了。利用面向对象的原则，例如继承和纯虚拟基类(想想接口)是创建具有良好结构的框架的好方法。

步骤5：媒体(音频和图形)

到现在为止，你至少已经考虑过你想让这个游戏看起来像什么样子，有了一套媒体可以使用。大量的免费图形和声音效果仅仅是谷歌搜索的地方。Audacity和GIMP是编辑您所获得或创建的任何内容的不可缺少的工具。

第六步：写游戏

一旦您选择了一个引擎或使用您自己的框架，您就可以实际编写游戏逻辑本身。理想情况下，在花费无数个小时之前，您至少已经完整地阅读了一篇文章，您将永远不会回到创建一个“引擎”的过程中，这个“引擎”超越了它的角色，几乎无法使用，但不足以独立运行。您的框架应该提供一个基础，用于构造对象交互(但不一定定义它)，并处理所有渲染和其他低级细节，如物理。游戏逻辑本身将定义对象交互(例如，通过定义GameObject的子类)、游戏规则(例如什么构成输赢)、游戏的初始状态(首先加载哪个地图、您从哪个项目开始，等等)，并包含主游戏回路。



游戏的主回路到底是什么？简单地说：这是一个循环，主循环。想想看，在玩游戏的时候，什么东西会被不断重复，这些就是这个神秘的循环中包含的东西。例如，每次迭代游戏都应该更新所有的对象，然后将它们全部绘制到屏幕上。除了更新和绘图之外，主循环还可能负责计时。对用户来说，更新太多的游戏看起来非常快，而且很可能太难了。以光速思考乒乓球。理想情况下，这个循环将使用您先前创建的框架，并且非常简单。

第七步：从里面取点东西 

创建一个独立于游戏逻辑的框架的主要原因是为了让您学会编写可重用的代码。

初学者放弃项目的主要原因之一是他们花费了大量的时间和精力试图为他们的游戏“编写一个引擎”，但是他们还不知道一个好的引擎甚至包括了什么，或者一个结构/界面是否真的能工作。在浪费了所有的时间之后，他们没有什么可展示的，然后灰心丧气并因此退出。

通过首先编写游戏，然后编写可重用的代码，理想情况下，您将得到一些您可以看到的东西。这是对你的努力的一个实实在在的奖励，也是一个继续努力工作的理由。

在游戏中考虑加入这些：

可以尝试用游戏代码制作可移植模块。

编写了一个非常棒的资源管理器或出色的类来处理键盘输入，让它们完全可移植。

步骤8：打包和分发 

将所有所需文件打包到一个压缩文件、压缩存档或可执行安装程序中，并发送给每个人！

 

          
为何需要线程？线程有哪些优点？
一、前序
首先了解一些基本的知识，现在所用的操作系统大多为多任务系统（分时操作系统）。所谓分时操作系统，就
是指可以同时执行多个程序的操作系统。具体地如：我们可以同时上网聊天、看电影、听音乐、玩游戏...。实际
上并不是CPU在同时执行这些程序，CPU将时间分割为一段段很小的时间片分配给这些程序，获得时间片的程
序开始执行，因为分配到的时间很短所以不等执行完毕，下一个程序有获得时间片开始执行程序。如此，多个
程序轮流执行一段很短的时间，由于CPU的高速计算能力，给人的感觉就像是多个程序同时运行一样。
二、进程的概念
有了以上的铺垫，下面我们再来了解一下“进程”。在多任务操作系统中都有进程这个概念。所谓进程，就
是指一个独立运行的应用程序实例，如上面提到的聊天程序。每个进程都有自己私有的虚拟地址空间（独立的
一块内存空间）、代码、数据和其他系统资源。进程在运行时创建的资源随着程序的终止而死亡。在进程的概
念中，每个进程的内部数据都是完全独立的，因此可以想象创建并执行多个进程的系统，内存开销是比较大
的。所以，线程此时应运而生。
三、线程的概念
与进程相似，线程是一段完成某个特定功能的代码，是程序中单个顺序的控制流；而与进程不同的是，同类
的多个线程是共享一块内存空间和一组系统资源的，而线程本身的数据通常只有微处理器的寄存器数据，以及
一个供程序执行时使用的堆栈。因此系统在产生一个线程，所花费的空间远远小于启动一个进程所花费的空
间，而且线程间彼此切换所需的时间也远远小于进程间切换所花费的时间。正因为如此，线程也被称为轻负荷
进程。线程本质上，是进程中的一段并发运行代码，所以线程需要操作系统投入CPU资源来运行和调度。
线程的状态有，创建、可运行、运行中、阻塞、死亡五种状态。线程从创建、运行到消亡的过程成为线程的生
命周期。通过线程的控制与调度可使线程在这几种状态间转化，每个程序至少自动拥有一个线程，成为主线
程。当程序加载到内存时，启动主线程。
四、线程的优/缺点
优点：
使用多线程的优点：
1).耗时的操作使用线程，能提高应用程序响应。
2).并行操作时使用线程，如C/S架构的服务器端并发线程响应用户请求。
3).多CPU系统中，使用线程提高CPU的利用率。
4).改善程序的结构。长而复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运
行部分，这样有利与程序的理解和修改。
5).空间花销小，线程间的切换快。
6).线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的
方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以
一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。
缺点：
必须认识到线程本身可能影响系统性能的不利方面，以正确使用线程：
1).线程也是程序，所以线程需要占用内存，线程越多占用内存也越多
2).多线程需要协调和管理，所以需要CPU时间跟踪线程
3).线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题
4).线程太多会导致控制太复杂，最终可能造成很多Bug
欢迎各位高手提出建议加以改正、补充!
以上总结参考了：http://dev.firnow.com/course/4_webprogram/asp.net/netjs/200847/108719.html
http://java.chinaitlab.com/line/373702.html

				
转载于:https://blog.51cto.com/sicny/485974