【VxWorks5(3)，2024年最新一次违反常规的Golang大厂面试经历

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

---

02b,22sep92,rrr added support for c++
02a,04jul92,jcf cleaned up.
01k,26may92,rrr the tree shuffle
01j,04oct91,rrr passed through the ansification filter
-changed VOID to void
-changed copyright notice
01i,06apr91,gae added NOMANUAL to avoid fooling mangen.
01h,05oct90,shl added ANSI function prototypes.
made #endif ANSI style.
added copyright notice.
01g,10aug90,dnw added declaration of rngFlush().
01f,07aug90,shl moved function declarations to end of file.
01e,22aug88,gae removed incorrect comment about using ‘shorts’
for optimization.
01d,30may88,dnw changed to v4 names.
01c,10nov87,dnw changed ring pointers from shorts to ints.
rings can now be > 32K bytes.
01b,15aug84,dnw removed several macros, now routines in rngLib.cs;
only rngGetC and rngPutC remain as macros.
01a,06jun84,dnw culled from old drvLib.h
*/

#ifndef __INCrngLibh
#define __INCrngLibh

#ifdef __cplusplus
extern “C” {
#endif

/* HIDDEN */

/* typedefs */

typedef struct /* RING - ring buffer /
{
int pToBuf; / offset from start of buffer where to write next /
int pFromBuf; / offset from start of buffer where to read next /
int bufSize; / size of ring in bytes */
char buf; / pointer to start of buffer */
} RING;

/* END_HIDDEN */

typedef RING *RING_ID;

/*

• The following macros are designed to do various operations on
• the RING object. By using them, users can avoid having to know
• the structure of RING. However they are intended to be very
• efficient and this is why they are macros in the first place.
• In general the parameters to them should be register variables
• for maximum efficiency.
  */

/*******************************************************************************
*

• RNG_ELEM_GET - get one character from a ring buffer
• This macro gets a single character from the specified ring buffer.
• Must supply temporary variable (register int) ‘fromP’.
• RETURNS: 1 if there was a char in the buffer to return, 0 otherwise
• NOMANUAL
  */

#define RNG_ELEM_GET(ringId, pCh, fromP)
(
fromP = (ringId)->pFromBuf,
((ringId)->pToBuf == fromP) ?
0
:
(
*pCh = (ringId)->buf[fromP],
(ringId)->pFromBuf = ((++fromP == (ringId)->bufSize) ? 0 : fromP),
1
)
)

/*******************************************************************************
*

• RNG_ELEM_PUT - put one character into a ring buffer
• This macro puts a single character into the specified ring buffer.
• Must supply temporary variable (register int) ‘toP’.
• RETURNS: 1 if there was room in the buffer for the char, 0 otherwise
• NOMANUAL
  */

#define RNG_ELEM_PUT(ringId, ch, toP)
(
toP = (ringId)->pToBuf,
(toP == (ringId)->pFromBuf - 1) ?
0
:
(
(toP == (ringId)->bufSize - 1) ?
(
((ringId)->pFromBuf == 0) ?
0
:
(
(ringId)->buf[toP] = ch,
(ringId)->pToBuf = 0,
1
)
)
:
(
(ringId)->buf[toP] = ch,
(ringId)->pToBuf++,
1
)
)
)

/* function declarations */

#if defined(STDC) || defined(__cplusplus)

extern BOOL rngIsEmpty (RING_ID ringId);
extern BOOL rngIsFull (RING_ID ringId);
extern RING_ID rngCreate (int nbytes);
extern int rngBufGet (RING_ID rngId, char *buffer, int maxbytes);
extern int rngBufPut (RING_ID rngId, char *buffer, int nbytes);
extern int rngFreeBytes (RING_ID ringId);
extern int rngNBytes (RING_ID ringId);
extern void rngDelete (RING_ID ringId);
extern void rngFlush (RING_ID ringId);
extern void rngMoveAhead (RING_ID ringId, int n);
extern void rngPutAhead (RING_ID ringId, char byte, int offset);

#else /* STDC */

extern BOOL rngIsEmpty ();
extern BOOL rngIsFull ();
extern RING_ID rngCreate ();
extern int rngBufGet ();
extern int rngBufPut ();
extern int rngFreeBytes ();
extern int rngNBytes ();
extern void rngDelete ();
extern void rngFlush ();
extern void rngMoveAhead ();
extern void rngPutAhead ();

#endif /* STDC */

#ifdef __cplusplus
}
#endif

#endif /* __INCrngLibh */

继续看rngLib.c

/* rngLib.c - ring buffer subroutine library */

/* Copyright 1984-1995 Wind River Systems, Inc. */
#include “copyright_wrs.h”

/*
modification history

01x,13feb95,jdi doc tweaks.
01w,20jan93,jdi documentation cleanup for 5.1.
01v,26may92,rrr the tree shuffle
01u,11jan92,wmd fix bug spr #1210, race condition based on updates of buf
pointers in more than 1 place in rngBufPut() and rngBufGet().
01t,13dec91,gae ANSI cleanup.
01s,04oct91,rrr passed through the ansification filter
-changed functions to ansi style
-changed VOID to void
-changed copyright notice
01r,05apr91,jdi documentation – removed header parens and x-ref numbers;
doc review by dnw.
01q,11mar91,jaa documentation cleanup.
01p,11may90,yao added missing modification history (01o) for the last checkin.
01o,09may90,yao typecasted malloc to (char *).
01n,22mar89,dab changed shorts to ints in rngBufGet, rngBufPut.
01m,03feb89,dab added rngDelete to delete a ring buffer.
01l,20aug88,gae documentation.
01k,07jul88,jcf fixed malloc to match new declaration.
01j,30may88,dnw changed to v4 names.
01i,03nov87,ecs documentation.
01h,20oct87,gae documentation.
01g,23mar87,jlf documentation.
01f,21dec86,dnw changed to not get include files from default directories.
01e,14apr86,rdc changed memAllocates to mallocs.
01d,20jul85,jlf documentation.
01c,09sep84,jlf added comments and copyright.
01b,15aug84,dnw changed rngBufCreate to allocate ring buffer one byte larger
than requested, because ring buffer algorithm always leaves
at least one empty byte in buffer.
added rngEmpty, rngFull, rngFreeBytes, rngNBytes, rngFlush,
rngPutAhead, rngMoveAhead, some of which used to be
macros in rngLib.h.
changed rngBufGet,rngBufPut to rngGetBuf,rngPutBuf.
changed rngBufCreate to rngCreate.
01a,06jun84,dnw culled from old drvLib.c
*/

/*
This library provides routines for creating and using ring buffers, which
are first-in-first-out circular buffers. The routines simply manipulate
the ring buffer data structure; no kernel functions are invoked. In
particular, ring buffers by themselves provide no task synchronization or
mutual exclusion.

However, the ring buffer pointers are manipulated in such a way that a
reader task (invoking rngBufGet()) and a writer task (invoking
rngBufPut()) can access a ring simultaneously without requiring mutual
exclusion. This is because readers only affect a \f2read\f1 pointer and
writers only affect a \f2write\f1 pointer in a ring buffer data structure.
However, access by multiple readers or writers \f2must\fP be interlocked
through a mutual exclusion mechanism (i.e., a mutual-exclusion semaphore
guarding a ring buffer).

This library also supplies two macros, RNG_ELEM_PUT and RNG_ELEM_GET,
for putting and getting single bytes from a ring buffer. They are defined
in rngLib.h.
.CS
int RNG_ELEM_GET (ringId, pch, fromP)
int RNG_ELEM_PUT (ringId, ch, toP)
.CE
Both macros require a temporary variable or , which
should be declared as `register int’ for maximum efficiency. RNG_ELEM_GET
returns 1 if there was a character available in the buffer; it returns 0
otherwise. RNG_ELEM_PUT returns 1 if there was room in the buffer; it returns
0 otherwise. These are somewhat faster than rngBufPut() and rngBufGet(),
which can put and get multi-byte buffers.

INCLUDE FILES: rngLib.h
*/

/* LINTLIBRARY */

#include “vxWorks.h”
#include “memLib.h”
#include “rngLib.h”
#include “stdlib.h”
#include “string.h”

/*******************************************************************************
*

• rngCreate - create an empty ring buffer
• This routine creates a ring buffer of size , and initializes
• it. Memory for the buffer is allocated from the system memory partition.
• RETURNS
• The ID of the ring buffer, or NULL if memory cannot be allocated.
  */

RING_ID rngCreate
(
int nbytes /* number of bytes in ring buffer */
)
{
char *buffer;
RING_ID ringId = (RING_ID) malloc (sizeof (RING));

if (ringId == NULL)
return (NULL);

/* bump number of bytes requested because ring buffer algorithm

• always leaves at least one empty byte in buffer */

buffer = (char *) malloc ((unsigned) ++nbytes);

if (buffer == NULL)
{
free ((char *)ringId);
return (NULL);
}

ringId->bufSize = nbytes;
ringId->buf = buffer;

rngFlush (ringId);

return (ringId);
}
/*******************************************************************************
*

• rngDelete - delete a ring buffer
• This routine deletes a specified ring buffer.
• Any data currently in the buffer will be lost.
• RETURNS: N/A
  */

void rngDelete
(
FAST RING_ID ringId /* ring buffer to delete /
)
{
free (ringId->buf);
free ((char )ringId);
}
/*****************************************************************************
*

• rngFlush - make a ring buffer empty
• This routine initializes a specified ring buffer to be empty.
• Any data currently in the buffer will be lost.
• RETURNS: N/A
  */

void rngFlush
(
FAST RING_ID ringId /* ring buffer to initialize /
)
{
ringId->pToBuf = 0;
ringId->pFromBuf = 0;
}
/******************************************************************************
*

• rngBufGet - get characters from a ring buffer
• This routine copies bytes from the ring buffer into .
• It copies as many bytes as are available in the ring, up to .
• The bytes copied will be removed from the ring.
• RETURNS:
• The number of bytes actually received from the ring buffer;
• it may be zero if the ring buffer is empty at the time of the call.
  */

int rngBufGet
(
FAST RING_ID rngId, /* ring buffer to get data from */
char buffer, / pointer to buffer to receive data /
int maxbytes / maximum number of bytes to get */
)
{
FAST int bytesgot = 0;
int pToBuf = rngId->pToBuf;
int bytes2;
int pRngTmp = 0;

if (pToBuf >= rngId->pFromBuf)
{
/* pToBuf has not wrapped around */

bytesgot = min (maxbytes, pToBuf - rngId->pFromBuf);
bcopy (&rngId->buf [rngId->pFromBuf], buffer, bytesgot);
rngId->pFromBuf += bytesgot;
}
else
{
/* pToBuf has wrapped around. Grab chars up to the end of the

• buffer, then wrap around if we need to. */

bytesgot = min (maxbytes, rngId->bufSize - rngId->pFromBuf);
bcopy (&rngId->buf [rngId->pFromBuf], buffer, bytesgot);
pRngTmp = rngId->pFromBuf + bytesgot;

/* If pFromBuf is equal to bufSize, we’ve read the entire buffer,

• and need to wrap now. If bytesgot < maxbytes, copy some more chars
• in now. */

if (pRngTmp == rngId->bufSize)
{

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

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）

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

• and need to wrap now. If bytesgot < maxbytes, copy some more chars
• in now. */

if (pRngTmp == rngId->bufSize)
{

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

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-lAfHfn7X-1713439470950)]

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