深入研究源码:Android10(1)

//对参数进行解析
for (int i = 1; i < argv.length; i++) {
if (“start-system-server”.equals(argv[i])) { //参数重包含start-system-server
startSystemServer = true; //设置标志为位true
} else if (“–enable-lazy-preload”.equals(argv[i])) {
enableLazyPreload = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) { //获取支持的架构列表
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}

final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);//根据socketName判断是否是primaryZygote,可能还有secondZygote

if (abiList == null) { //如果支持架构为空,直接抛出异常
throw new RuntimeException(“No ABI list supplied.”);
}

// In some configurations, we avoid preloading resources and classes eagerly.
// In such cases, we will preload things prior to our first fork.
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin(“ZygotePreload”);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
} else {
Zygote.resetNicePriority();
}

// Do an initial gc to clean up after startup
bootTimingsTraceLog.traceBegin(“PostZygoteInitGC”);
gcAndFinalize(); //调用ZygoteHooks.gcAndFinalize()进行垃圾回收
bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC

bootTimingsTraceLog.traceEnd(); // ZygoteInit
// Disable tracing so that forked processes do not inherit stale tracing tags from
// Zygote.
Trace.setTracingEnabled(false, 0);

Zygote.initNativeState(isPrimaryZygote);//jni调用初始化zygote的状态,是否为isPrimaryZygote

ZygoteHooks.stopZygoteNoThreadCreation(); //结束zygote创建,其实内部是调用runtimezygote_no_threads_赋值为false,为创建本地线程做准备

zygoteServer = new ZygoteServer(isPrimaryZygote); //创建zygoteServer,为其他进程初始化创建时与zygote通信做准备

if (startSystemServer) { //判断是否需要startSystemServer
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);//通过fork的方式开启zygote的子进程,systemServer,并返回一个Runnale对象
// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) {//如果是zygote进程,则r==null,如果不是zygote进程,也就是systemServer进程,则执行下面的代码
r.run();
return;
}
}

Log.i(TAG, “Accepting command socket connections”);

// The select loop returns early in the child process after a fork and
// loops forever in the zygote.
caller = zygoteServer.runSelectLoop(abiList); //zygote进程进入死循环中,来获取子进程发送的消息
} catch (Throwable ex) {
Log.e(TAG, “System zygote died with exception”, ex);
throw ex;
} finally {
if (zygoteServer != null) {
zygoteServer.closeServerSocket(); //如果发生异常,则说明zygote初始化失败,zygoteServer也需要关闭
}
}

// We’re in the child process and have exited the select loop. Proceed to execute the
// command.
if (caller != null) {
caller.run();
}
}

zygote的大概流程我们已经梳理完了,现在我们来总结一下

  1. 解析对应的zyogte.rc脚本
  2. 调用app_process/appMain.cpp
  3. 设置进程名为zygote
  4. 调用zygoteInit.java初始化zygote进程
  5. JNI调用zygoteInit.cpp完成进程创建
  6. 调用runSelectionLoop(),接收其他进程发送的消息创建子进程

Zygote是如何fork出SystemServer的

我们都知道,Android系统中,zyogte进程是Java世界的首个进程(init进程为头号进程),是直接通过exec的系统调用创建的,其他的进程,包括system_server,都是zygote进程的子进程,那我们接下来从源码的角度来看一下,zygote是如何forksystem_server

public static void main(String argv[]) {

if (startSystemServer) {
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);

// {@code r == null} in the parent (zygote) process, and {@code r != null} in the
// child (system_server) process.
if (r != null) { //如果r不为空,说明是system_server进程
r.run(); //调用其run方法
return;
}
}


}

}

由上面的分析我们看到,根据zygote.rc的参数,解析出是否需要startSystemServer,如果为true,则调用forkSystemServer来fork出子进程SystemServer,并且执行其返回的Runnable的run()方法,我们先来看看forkSystemServer具体做了什么

/**

  • Prepare the arguments and forks for the system server process.
  • 为forkSystemServer进程准备参数,并且创建system server进程
  • @return A {@code Runnable} that provides an entrypoint into system_server code in the child
  • process; {@code null} in the parent.
    /
    private static Runnable forkSystemServer(String abiList, String socketName,
    ZygoteServer zygoteServer) {
    //Linux使用POSIX capabilities代替传统的信任状模型
    long capabilities = posixCapabilitiesAsBits( //设置进程权能
    OsConstants.CAP_IPC_LOCK, //允许锁定共享内存片段
    OsConstants.CAP_KILL, //允许对不属于自己的进程发送信号
    OsConstants.CAP_NET_ADMIN, // 允许执行网络管理任务:接口、防火墙和路由等
    OsConstants.CAP_NET_BIND_SERVICE, //允许绑定到小于1024的端口
    OsConstants.CAP_NET_BROADCAST, //允许网络广播和多播访问
    OsConstants.CAP_NET_RAW, //允许网络广播和多播访问
    OsConstants.CAP_SYS_MODULE, //插入和删除内核模块
    OsConstants.CAP_SYS_NICE, //允许提升优先级,设置其它进程的优先级
    OsConstants.CAP_SYS_PTRACE, //允许配置进程记帐
    OsConstants.CAP_SYS_TIME, //允许改变系统时钟
    OsConstants.CAP_SYS_TTY_CONFIG, //允许配置TTY设备
    OsConstants.CAP_WAKE_ALARM,
    OsConstants.CAP_BLOCK_SUSPEND
    );
    /
    Containers run without some capabilities, so drop any caps that are not available. */
    StructCapUserHeader header = new StructCapUserHeader(
    OsConstants._LINUX_CAPABILITY_VERSION_3, 0);
    StructCapUserData[] data; //用户权能数据
    try {
    data = Os.capget(header); //获取进程权能,存储到data中
    } catch (ErrnoException ex) {
    throw new RuntimeException(“Failed to capget()”, ex);
    }
    capabilities &= ((long) data[0].effective) | (((long) data[1].effective) << 32);

/* Hardcoded command line to start the system server */
/使用硬编码的方式定义出启动system server的参数字符串args/
String args[] = {
“–setuid=1000”, //用户id
“–setgid=1000”,//用户组id
“–setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,”

  • “1024,1032,1065,3001,3002,3003,3006,3007,3009,3010”,
    “–capabilities=” + capabilities + “,” + capabilities, //进程权能
    “–nice-name=system_server”, //进程niceName
    “–runtime-args”,
    “–target-sdk-version=” + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
    “com.android.server.SystemServer”,
    };
    ZygoteArguments parsedArgs = null;

int pid; //processId,进程id

try {

parsedArgs = new ZygoteArguments(args); 创建ZygoteArguments对象,把args解析为需要的参数
Zygote.applyDebuggerSystemProperty(parsedArgs);
Zygote.applyInvokeWithSystemProperty(parsedArgs);

boolean profileSystemServer = SystemProperties.getBoolean(
“dalvik.vm.profilesystemserver”, false); //跟Art虚拟机相关,暂时不做深究
if (profileSystemServer) {
parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;
}

/* Request to fork the system server process */
pid = Zygote.forkSystemServer( //fork创建SystemServer
parsedArgs.mUid, parsedArgs.mGid,
parsedArgs.mGids,
parsedArgs.mRuntimeFlags,
null,
parsedArgs.mPermittedCapabilities,
parsedArgs.mEffectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}

/* For child process */
if (pid == 0) { //pid为0,则说明是zygote进程,进行最后的收尾工作
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}

zygoteServer.closeServerSocket();
return handleSystemServerProcess(parsedArgs);
}

return null;
}

代码最后调用了Zygote.forkSystemServer()来创建SystemServer,我们接着来跟一下

public static int forkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
ZygoteHooks.preFork();//内部调用ART的Runtime对zygote的线程池的线程进行清理
// Resets nice priority for zygote process.
resetNicePriority();
int pid = nativeForkSystemServer( //JNI调用,真正创建systemServer进程的函数
uid, gid, gids, runtimeFlags, rlimits,
permittedCapabilities, effectiveCapabilities);
// Enable tracing as soon as we enter the system_server.
if (pid == 0) {
Trace.setTracingEnabled(true, runtimeFlags);
}
ZygoteHooks.postForkCommon();
return pid;
}

接着跟下去,到c++的本地代码中 zygote.cpp

static jint com_android_internal_os_Zygote_nativeForkSystemServer(
JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
jint runtime_flags, jobjectArray rlimits, jlong permitted_capabilities,
jlong effective_capabilities) {

pid_t pid = ForkCommon(env, true,
fds_to_close,
fds_to_ignore);//从zygote进程fork出子进程,并返回processId

return pid;
}

到这里我们就把相关源码分析完了,我们来总结下:

  1. 解析zygote.rc的相关脚本,获取startSystemserver的属性字段
  2. 调用startSystemServer()
  3. 调用forkSystemServer(),为当前进程赋予权限,并设置UID,GID
  4. 创建ZygoteArgument,调用zygote.forkSystemServer
  5. JNI调用native的函数,nativeForkSystemServer完成进程的fork工作

普通进程(UASP–unspecialized app process),是通过什么方式被fork出来的

这里我们只分析zygote相关的源码,完整流程等分析AMS时一起总结

zygoteInit中,最后调用了zyogteServer的runSelectionLoop()函数,进入一个无限循环中,我们来看下代码

Runnable runSelectLoop(String abiList) { //此处使用了selcet IO复用机制,这个我们以后专门来分析Linux的IO复用机制

while (–pollIndex >= 0) {

if (pollIndex == 0) {
// Zygote server socket

ZygoteConnection newPeer = acceptCommandPeer(abiList);//创建socket连接的服务端
peers.add(newPeer);
socketFDs.add(newPeer.getFileDescriptor());

} else if (pollIndex < usapPoolEventFDIndex) {
// Session socket accepted from the Zygote server socket

try {
ZygoteConnection connection = peers.get(pollIndex); //获取到客户端连接对象ZygoteConnection
final Runnable command = connection.processOneCommand(this); //读取一个sokcet命令,并fork出子进程,执行子进程的main函数

// TODO (chriswailes): Is this extra check necessary?
if (mIsForkChild) {
// We’re in the child. We should always have a command to run at this
// stage if processOneCommand hasn’t called “exec”.
if (command == null) {
throw new IllegalStateException(“command == null”);
}

return command;
} else {
// We’re in the server - we should never have any commands to run.
if (command != null) {
throw new IllegalStateException(“command != null”);
}

// We don’t know whether the remote side of the socket was closed or
// not until we attempt to read from it from processOneCommand. This
// shows up as a regular POLLIN event in our regular processing loop.
if (connection.isClosedByPeer()) {
connection.closeSocket();
peers.remove(pollIndex);
socketFDs.remove(pollIndex);
}
}
}

}


}
}

这里当pollIndex==0先调用acceptCommandPeer()创建sokcet连接的服务端,其他条件下,调用acceptCommandPeer()获取一个ZygoteConnect对象,并执行其processOneCommand()函数,读取一个sokcet命令,并fork出子进程,执行子进程的main函数,我们还是接着跟一下这个函数

Runnable processOneCommand(ZygoteServer zygoteServer) {
String args[];
ZygoteArguments parsedArgs = null;
FileDescriptor[] descriptors;

try {
args = Zygote.readArgumentList(mSocketReader); //从sokcet中读取参数

// TODO (chriswailes): Remove this and add an assert.
descriptors = mSocket.getAncillaryFileDescriptors(); //获取其附带的文件描述符
} catch (IOException ex) {
throw new IllegalStateException(“IOException on command socket”, ex);
}

int pid = -1;
FileDescriptor childPipeFd = null;//子进程,使用管道进行进程间通信,
FileDescriptor serverPipeFd = null;

parsedArgs = new ZygoteArguments(args); //创建Zygote参数对象

pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mTargetSdkVersion);
//Forks a new VM instance
//创建一个新的VM实例对象,也就是我们平时说的沙盒隔离机制(sandbox)

try {
if (pid == 0) {
// in child
zygoteServer.setForkChild();//设置标志位mIsForkChild为true

return handleChildProc(parsedArgs, descriptors, childPipeFd,
parsedArgs.mStartChildZygote); //处理子进程的创建
} else {
// In the parent. A pid < 0 indicates a failure and will be handled in
// handleParentProc.
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
handleParentProc(pid, descriptors, serverPipeFd);//如果pid>0,则为子进程设置进程号,否则就是创建失败
return null;
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}

这里根据传递过来的参数创建zygoteArgs对象,并创建出VM虚拟机对象,最终调用handleChildProc()来创建子进程,继续跟踪代码

private Runnable handleChildProc(ZygoteArguments parsedArgs, FileDescriptor[] descriptors,
FileDescriptor pipeFd, boolean isZygote) {

if (parsedArgs.mNiceName != null) { //判断mNiceName不为空
Process.setArgV0(parsedArgs.mNiceName); //设置mNiceName为进程名
}

// End of the postFork event.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
if (parsedArgs.mInvokeWith != null) { //判断参数中mInvokeWith为空时,使用exec的系统调用开启进程

} else {
if (!isZygote) { //非zygote模式
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mRemainingArgs, null /* classLoader /);
} else { //zygote模式
return ZygoteInit.childZygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mRemainingArgs, null /
classLoader */); //zygoteInit的备选函数,同时初始化Zygote进程
}
}
}

此处我们只关心由Zyogte进程fork出子进程的情况,跟踪zygoteInit()这个函数

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {

RuntimeInit.commonInit(); //对runtime进行初始化
ZygoteInit.nativeZygoteInit(); //JNI调用,nativeZygoteInit
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);//找到Appde 主函数并初始化调用
}

这里首先的对Runtime进行初始化,然后通过JNI对zygote进行真正的初始化操作,函数代码如下

static AndroidRuntime* gCurRuntime = NULL;
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit(); //调用AndroidRuntime的zygoteInit
}

这里是调用了AndroidRuntimeonZygoteInit(),此处点进去可以看到它是一个虚函数,那么应该是由的子类对象来做的具体实现,之前我们也分析过,AndroidRuntimeapp_processapp_main中又一个子类对象AppRuntime,我们来看一下

public:
AppRuntime(char* argBlockStart, const size_t argBlockLength)
: AndroidRuntime(argBlockStart, argBlockLength)
, mClass(NULL)
{
}

virtual void onZygoteInit()
{
sp proc = ProcessState::self();
ALOGV(“App process: starting thread pool.\n”);
proc->startThreadPool();//开启Bind线程池线程,设置线程名称
}

};

此处创建了一个ProcessState的对象,并调用了它的startThreadPool()函数,跟踪下去可以发现内部调用了spawnPooledThread的函数来创建线程并启动的

void ProcessState::spawnPooledThread(bool isMain)
{
if (mThreadPoolStarted) { //判断线程已开启
String8 name = makeBinderThreadName(); //创建Binder线程池名称
ALOGV(“Spawning new pooled thread, name=%s\n”, name.string());
sp t = new PoolThread(isMain); //创建主线程
t->run(name.string()); //执行线程
}
}

handleChildProc()这一系列代码执行完毕后,会调用handleParentProc()对子进程创建状态进行判断,如果pid>0则说明创建成功,到此处我们子进程以及其相关线程就准备完毕了

现在来总结下

  1. 调用runSelectLoop,循环读取消息
  2. 调用acceptCommandPeer创建Sokcet服务端的连接对象ZygoteConnection
  3. 调用acceptOneCommand读取Soket的消息
  4. 解析参数,并创建虚拟机实例对象
  5. 调用handleChildProcess处理子进程的创建
  6. 调用zygoteInit.zyogteInit(args...)把参数传递进去
  7. 调用native方法,进行最终的初始化
  8. 回调到app_process/app_main.cppAppRuntime具体实现中
  9. 开启Binder线程池,完成子进程创建

额外加餐

ZygoteServer源码

上面我们分析Zygote流程时涉及到一个类,ZygoteServer,下面我们来具体看下,它是如何创建的

在zygote的main函数中是这么初始化的

zygoteServer = new ZygoteServer(isPrimaryZygote);

那我们就从这个构造函数入手

/**

  • Initialize the Zygote server with the Zygote server socket, USAP pool server socket, and USAP
  • pool event FD.
  • @param isPrimaryZygote If this is the primary Zygote or not.
    */
    ZygoteServer(boolean isPrimaryZygote) {
    mUsapPoolEventFD = Zygote.getUsapPoolEventFD();

if (isPrimaryZygote) { //根据zygote.rc中的参数判断是否是PrimaryZygote
mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);//把PRIMARY_SOCKET_NAME赋值给mZygoteSocket
mUsapPoolSocket =
Zygote.createManagedSocketFromInitSocket(
Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);//把USAP_POOL_PRIMARY_SOCKET_NAME赋值给mUsapPoolSocket
} else {
mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);//把SECONDARY_SOCKET_NAME赋值给mZygoteSocket
mUsapPoolSocket =
Zygote.createManagedSocketFromInitSocket(
Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);//把USAP_POOL_SECONDARY_SOCKET_NAME赋值给mUsapPoolSocket
}

fetchUsapPoolPolicyProps();

mUsapPoolSupported = true;
}

上面的代码里主要是把zygote.rc中的配置取出来,其中涉及到了两个socket,mZygoteSocketmUsapPoolSocket;也涉及到两个Zygote,PrimaryZygoteSecondZygote

但是你可能会奇怪,咱们的zygote.rc中,怎么没有这个东西呢?我再把这个文件贴一遍

WORKING_DIRECTORY/out/target/product/generic_x86/root/init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
user root
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks

唯一跟primary有关的,是socket usap_pool_primary stream 660 root system,那SecondZygote去哪了呢?

这个跟咱们编译的版本是有关系的,当前编译的版本中,只支持32为的应用,所以只有32位的PrimaryZygote,那咱们来看一下我根据源码编译的Pixel 2的Android10系统中有没有

使用adb shell 查看

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 cat init.zygote64_32.rc

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
class main
priority -20
user root
group root readproc reserved_disk
socket zygote stream 660 root system
socket usap_pool_primary stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks

最后

答应大伙的备战金三银四,大厂面试真题来啦!

这份资料我从春招开始,就会将各博客、论坛。网站上等优质的Android开发中高级面试题收集起来,然后全网寻找最优的解答方案。每一道面试题都是百分百的大厂面经真题+最优解答。包知识脉络 + 诸多细节。
节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习。

《960全网最全Android开发笔记》

《379页Android开发面试宝典》

包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。熟悉本文中列出的知识点会大大增加通过前两轮技术面试的几率。

如何使用它?
1.可以通过目录索引直接翻看需要的知识点,查漏补缺。
2.五角星数表示面试问到的频率,代表重要推荐指数

《507页Android开发相关源码解析》

只要是程序员,不管是Java还是Android,如果不去阅读源码,只看API文档,那就只是停留于皮毛,这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

真正最能锻炼能力的便是直接去阅读源码,不仅限于阅读各大系统源码,还包括各种优秀的开源库。

腾讯、字节跳动、阿里、百度等BAT大厂 2020-2021面试真题解析

资料收集不易,如果大家喜欢这篇文章,或者对你有帮助不妨多多点赞转发关注哦。文章会持续更新的。绝对干货!!!

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友,可以戳这里获取

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

6793)]

《507页Android开发相关源码解析》

只要是程序员,不管是Java还是Android,如果不去阅读源码,只看API文档,那就只是停留于皮毛,这对我们知识体系的建立和完备以及实战技术的提升都是不利的。

真正最能锻炼能力的便是直接去阅读源码,不仅限于阅读各大系统源码,还包括各种优秀的开源库。

[外链图片转存中…(img-pxkL9FoG-1714663436793)]

腾讯、字节跳动、阿里、百度等BAT大厂 2020-2021面试真题解析

[外链图片转存中…(img-vmsnJGQD-1714663436793)]

资料收集不易,如果大家喜欢这篇文章,或者对你有帮助不妨多多点赞转发关注哦。文章会持续更新的。绝对干货!!!

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友,可以戳这里获取

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

  • 22
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值