Most modern CPU's do not technically have a hardware stack (that is, there is no dedicated memory used just for the stack, largely because it's inefficient and you can't be sure exactly how much space you need on any real system). Almost all of them do have a stack pointer register however, which is what gets used by instructions that operate on the stack. However, each process still has it's own stack (actually, usually at least two stacks, but that gets into the intricacies of privilege separation between the OS and user programs, and isn't entirely relevant to the question), but the stack pointer register is shared by all processes (this register is part of what is saved and restored during a context switch, together with most of the rest of the CPU state).
To answer the second half of your question somewhat bluntly, multitasking is an illusion, it just depends on the scale. Each individual CPU core can run one process at a time, and it (usually) will switch between all processes on the system that aren't waiting on something at frequencies high enough that they're functionally running simultaneously from a human perspective (most operating systems with processes at a rate of 100 to 1000 times a second, which is still more than enough time for hundreds of millions of CPU instructions to be executed in each process). Looking at this a bit differently, a single core CPU is like a person, it has to switch its focus regularly to 'multi-task', and a multi-core CPU is like a team of people, each person can only do one thing at a time reliably, but taken as a whole, the team can easily work as many tasks as there are team members.
However, for the purposes of your class, all of this is either irrelevant (if the class is taught using a minimalistic OS like CP/M or DOS, which don't do multitasking, and therefore have a single stack, period) or will be covered in due time (if it's taught using a real OS like UNIX, MINIX, or even one of the various modern commercial offerings, all of which do multitasking, which is often covered near the end of the class because understanding it requires understanding the basics (like how a stack works)).