Can I do multiple (unrelated) things with my Arduino Uno?

The short answer is, yes - if you write your program properly.

Design your code so that the two functions that you want your Arduino to perform, each has their own neatly segregated routine that can run side by side without interfering with the other. So they have to be good neighbors. That means they can not use delay() which just makes everything (including the other process) grind to a halt. Define a time regimen for how often each of the two functions are run (once a second? 100 times a second?) and have for your main loop a simple scheduler function looking at millis() and comparing with timestamps to determine when to run each of the two (or more) functions you want to run side by side.

edit: To avoid variable names belonging to each process from "stepping on each other" , you can organize the data that each process type uses, into a struct. Structs are like records or data cards; for example, you could for your thermostat function store the high and low threshold set temperatures in a struct you can call ThermostatSetting. It could also contain a reference to the IO pins that the process uses. Then if for whatever reason you want to add more things to be temperature controlled, you can reuse the thermostat function and just call it with the different structs pertaining to each controlled thermostat. The same goes for lights. And anything else. The 16MHz Atmel CPU is plenty powerful to run basic home automation for a whole house.

A professor of mine at Aalborg University wrote a custom arduino kernel for exactly this purpose, called SNOT (Simple NOT) it works as a Semiphore and scheduling kernel, allowing you to designate several schedules to be executed "at the same time" in a very clever way.

Take a look at it and see if it is what you need http://www.control.aau.dk/~jdn/edu/doc/arduino/snot/

The short answer: kinda

The long answer: Unlike a Raspberry Pi (or any other computer) you can't have two totally separate programs running simultaneously on an arduino. To make these two processes run in tandem you would need to write your code cleverly.

One of the main things to do would be to minimise the time that any part of your code "hangs" the loop (i.e. the time it takes for a section of your code to run). The number one culprit for this is delay()! This holds your code for x number of milliseconds meaning that noting else can get done. A better way to do this would be to use millis(). You could store the current millis() and then check everytime your code loops to see if the current time is the stored time + x milliseconds. This means that your code can keep looping unimpeded and therefore be checking stuff related to the second task you wanted to run whilst the first task is waiting.

In your case it should be fairly straightforward as neither of your tasks require high timing precision. Simply have your beer fridge temperature sensor update itself every time the sketch runs (or use a millis() based bit of code to get it to check every so often) and then just below that in the loop update a variable from your photosensor and then turn the lamp on or off depending on it's output.

Just as a note: if you really want threads there is a port of freertos to the arduino that works pretty well plus several other RTOSes.

I've written a very simple (~50 line) schedule-driven framework that I'm currently working on filling out and writing up, I'll probably post about it within a week.

It lets you say "Check my position every 100 ms, regulate my speed every 50 ms, check if an infrared shutdown message (the topic of what I posted yesterday) has come in every 25ms" and it does it's best to do all those things.

It's not truly doing those things at the same time, it just tries it's best to run small bits of code on a schedule. Happy to share it with you ahead of schedule if you want.

this problem arises for every beginner sooner or later and there is something everyone must understand. an MCU can do a million things at once and there are several ways to make it do it. the only limitation is if it has the speed and io pins to do the tasks at hand. The biggest issue comes from the exposure and emphasis on the pause command and the while and do loops. these are called blocking calls and the only one that should exist is the main one which loops the entire program. Every tutorial relies heavily on these but aren't very useful when you want to do more than one thing at once.

To answer your question more specifically, you can do it with either interrupts(timer or io based) or with something called polling. there is no need to use fancy kernels or libraries or any of that fancy nonsense.

In essence you just write a main loop, use if statements to check conditions, and if a condition is met run some output. If anything needs delays or whatnot utilize some kind of timing mechanism(counting a variable, the millis() function and a variable trigger, or use interrupt timers) You do not want to have any pause commands. Essentially every function needs to be broken down into if statements and outputs be instant, then you can do as many things as the mcu is capable of(which is a lot)

You don't need an entire uno board to run a program. The little black chip on your uno is doing all the work. You can buy more chips for about $3.

Yes. You are doing three things, updating a display, regulating a thermo and checking the light levels on a lamp. Keep the thought of what you are doing as simple as possible. You don't need threads or anything special, just a good ole loop. Put all of these three things in a loop that can either sleep for x amount of time.

loop{
UpdateDisplay()
CheckThermo()
CheckLighting()// You should be tracking if the light is on already
Sleep()
}

As you don't want all three to be done at the same time, add a counter and set a while loop for each.

const int CheckLight = 3
conts int Checkthermo = 10
const int updatedisplay = 5
counterL = 0
counterT = 0
counterD = 0

loop{

if (counterD == updatedisplay)
{UpdateDisplay()
counterD = 0
}
if (counterT == Checkthermo) 
{CheckThermo()
counterT = 0
}
if (counterL == CheckLight)
{CheckLighting()
counterL =0
}


Sleep(xtime)
counterL++
counterT++
counterD++
}

Yes there are other ways to do it, but this would be a simple way...