你说的是技术岗吧，管理岗肯定不是这样的。
30-40岁不到这个岁数你想跳cto岗还不容易呢。

没事看看大马的一把手
93了

我见过要求30岁以下的
并不是admin一类的基础职位，是分公司的财务经理....

现实是
35岁以上找工作还需要盲投简历的话，人生就太失败了。35岁以上，找工作要靠人脉，要么自己是老板。

问题是有的人不愿意做管理岗啊
只喜欢做技术。做管理的又不一定比做技术的挣得多，两条track而已。

另外管理岗的人普遍技术一般般，没有什么过硬的吃饭本领，这种人失业了往往更难找工作。

cto，technical director 也算是管理岗啊，也可以一样做技术啊。。
只是单纯的别人指导你，而你只是做最基础的工作（例如程序员函数别人都设计好了，你来写这种的），年纪越大是越难混了。哪个国家都一样，不单单是中国。

你应该不是搞技术的
你说的那些cto director之类的职位明显是管理岗，而不是技术岗了。

我说的在technical track一路走下去的，并不是要管人，而是在某一个领域成为技术专家。比如java之父james gosling这种级别的大牛，都62岁了，到现在为止也就是亚马逊的一个distinguished engineer，并不需要去管人，但他在一个特定的技术领域是公司里广受尊敬的sme（subject matter expert），工资也并不比公司内部同级别的management track低，这就是在技术岗一路走下去的典型例子。

当然像你说得那种年纪很大，但技术能力一点儿都没长进，仍然只能在technical track上做一些初级工作的人，的确是在哪里都不太好找工作了。

那种高级技术专家，在国内会因为年龄找不到工作？
那种只要35的，是因为他只想招你过去当低级码农而已。。

我还真是搞技术的，今年37了。我写的代码，我相信本论坛能看懂的人都不多。例如，上周五刚写的。。

只是一个大的分布式存储数据结构中的mutex 。。基本没有版权问题，因为你拿来也没法用，是专门为特殊的结构写的。。

class shared_mutex {
struct lock {
// The top-most bit (exclusive) is an exclusive lock and only one thread
// is able to acquire the exclusive successfully. This bit indicates whether
// a thread successfully acquires the lock.
//
// Note that, once an exclusive lock is locked, it will never be unlocked unless
// the node is not modified due to some other errors.
//
// This is because it is non-sense to lock the same node to write twice: once
// a node is written to another copy, the old one will be put on readonly_list
// and will never be written again.
uint64_t exclusive : 1;
// Indciates the unique ID of this thread.
uint64_t id : 48;
// Number of threads that are going to write on the nodes beneath the current node.
uint64_t shared_count : 15;
};
std::atomic<lock> lock_ { {0, 0, 0} };

public:

// Try to acquire a shared lock (increase shared count by 1).
// The try lock shared can also be temporally blocked for a small time if
// someone else is also modifying the shared_count (either add or subtract)
// concurrently.
//
// It will only fail when someone else got the exclusive lock (i.e., will
// modify the current node).
//
// We do not provide block version of lock_shared because it's non-sense
// to wait for a writing thread (which may change current node as well as
// the parent nodes). We have to return false and release all the shared lock
// of parents path to allow the current writing thread to possibly proceed
// (to avoid dead lock).
bool try_lock_shared() noexcept {
// When there is already a write lock (meaning someone is waiting for
// write permission on the current node), return false (we don't allow
// any new thread to change on any node beneath the current node).
// They must wait for the current node to realese exlcusive_lock before
// continuing.
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
return false;
}

// If failed, meaning that someone else modified the current lock.
// If someone else obtains exclusive lock, we just simply return fail.
// If someone else just changed shared count (add or subtract), we try agian.
// We assume that such shared count change can't be blocked forever.
lock newlock;
do {
newlock = currentlock;
newlock.shared_count++;
}
while(!lock_.compare_exchange_weak(currentlock, newlock) && currentlock.exclusive == 0);

// If return true, we can be sure that no one else got exclusive lock for writing yet.
return currentlock.exclusive == 0;
}


// Unlock a shared lock (decrease the count by 1).
// Will always return true. May be blocked for a small time.
void unlock_shared() noexcept {
lock currentlock = lock_.load();

lock newlock;
do {
newlock = currentlock;
newlock.shared_count--;
}
while(!lock_.compare_exchange_weak(currentlock, newlock));
}


// Check whether shared lock is 0
bool check_all_shared_unlocked() noexcept {
lock currentlock = lock_.load();
// The thread who calls this, must be the thread that
// obtains the exlcusive lock.
assert(currentlock.id == utils::get_thread_id());
return currentlock.shared_count == 0;
}

// Wait for shared lock to be 0 for a specified duration.
bool wait_all_shared_unlocked_for(const std::chrono::nanoseconds &duration) noexcept {
return wait_all_shared_unlocked_until(std::chrono::high_resolution_clock::now() + duration);
}

// Wait for shared lock to be 0 until the given time.
bool wait_all_shared_unlocked_until(const std::chrono::high_resolution_clock::time_point &expire) noexcept {
bool result = false;
while( std::chrono::high_resolution_clock::now() < expire && !(result = check_all_shared_unlocked()) ) {
std::this_thread::yield();
}
return result;
}

// Wait for shared lock to be 0.
void wait_all_shared_unlocked() noexcept {
while (!check_all_shared_unlocked() ) {
std::this_thread::yield();
}
}

// Try to acquire an exclusive lock. It will set exlusive to be 1, and id to be the
// unique thread id.
//
// Will only fail if exclusive lock is obtained by some other thread.
//
// No blocking version is provided because it is non-sense to wait for another
// thread who has already writing permission (although the write may not be finalized,
// but we have to return fail and release all current shared lock to avoid dead lock).
bool try_lock() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
// If the same thread called try_lock on already locked mutex,
// it means we have some logic error somewhere.
assert(currentlock.id != id);

return false;
}

bool result = false;
lock newlock { 1, id, 0 };
do {
newlock.shared_count = currentlock.shared_count;
}
while(!(result = lock_.compare_exchange_weak(currentlock, newlock)) && currentlock.exclusive == 0);

return result;
}


// Unlock the exlusive lock. Shall only be called if no writing is done
// on the node (e.g., due to recursive exclusive call failed for parents node.)
void unlock() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
assert(currentlock.exclusive == 1 && currentlock.id == id);

lock newlock { 0, 0, 0 };
do {
newlock.shared_count = currentlock.shared_count;
}
while (lock_.compare_exchange_weak(currentlock, newlock));
}

// Try to convert a shared lock to an exclusive lock.
// If successful, shared lock will be unlocked.
// If failed, nothing will be changed.
bool try_shared_to_exclusive() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
if (currentlock.exclusive == 1) {
assert(currentlock.id != id);
return false;
}

bool result = false;
lock newlock { 1, id, 0 };
do {
assert(currentlock.shared_count > 0);
newlock.shared_count = currentlock.shared_count - 1;
}
while(!(result = lock_.compare_exchange_weak(currentlock, newlock)) && currentlock.exclusive == 0);

return result;
}

// Try to convert an exclusive lock to a shared lock.
// If successful, exclusive lock will be released.
// This function will not fail.
void exclusive_to_shared() noexcept {
uint64_t id = utils::get_thread_id();
lock currentlock = lock_.load();
assert(currentlock.exclusive == 1 && currentlock.id == id);

lock newlock { 0, 0, 0 };
do {
newlock.shared_count = currentlock.shared_count + 1;
}
while (lock_.compare_exchange_weak(currentlock, newlock));
}
};